oknozor/pijul - Change CCLLB7OIFNFYJZTG3UCI7536TOCWSCSXR67VELSB466R24WLJSDAC

Upgrading to Sanakirja 0.15 + version bump

Created by pmeunier on December 31, 2020

CCLLB7OIFNFYJZTG3UCI7536TOCWSCSXR67VELSB466R24WLJSDAC

Dependencies

In channels

main

Change contents

Deletion in pijul-macros/src/lib.rs at line 36 [22.445]
B:BD[22.1411] → [22.1411:1434]
```
        #[doc(hidden)]
```

Insertion in pijul-macros/src/lib.rs at line 52 [22.445]

[22.2144]

    let error = next(&mut input_iter);
    let error = if error.is_empty() {
        quote! { Error }
    } else {
        proc_macro2::TokenStream::from_iter(error.into_iter())
    };

Replacement in pijul-macros/src/lib.rs at line 69 [22.445]

B:BD[22.2496] → [22.2496:2553]

        quote! { self.txn.get(&self.#name, key, value) }

[22.2496]

[22.2553]

        quote! { if let Ok(x) = self.txn.get(&self.#name, key, value) {
            Ok(x)
        } else {
            Err(TxnErr(SanakirjaError::PristineCorrupt))
        }
        }

Replacement in pijul-macros/src/lib.rs at line 76 [22.445]

B:BD[22.2566] → [22.2566:2632]

        quote! { self.txn.get(&self.#name, key, value) . #post_ }

[22.2566]

[22.2632]

        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 83 [22.445]

B:BD[22.2682] → [22.2682:2800]

        #[doc(hidden)]
        fn #name_get <'txn> (&'txn self, key: #key, value: Option<#value>) -> Option<#value> {

[22.2682]

[22.2800]

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

Insertion in pijul-macros/src/lib.rs at line 103 [22.445]

[22.3586]

    let error = next(&mut input_iter);
    let error = if error.is_empty() {
        quote! { Error }
    } else {
        proc_macro2::TokenStream::from_iter(error.into_iter())
    };

Replacement in pijul-macros/src/lib.rs at line 111 [22.445]

B:BD[22.3671] → [22.3671:3802]

        #[doc(hidden)]
        fn #name_get(&self, db: &Self::#name_capital, key: #key, value: Option<#value>) -> Option<#value> {

[22.3671]

[22.3802]

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

Replacement in pijul-macros/src/lib.rs at line 113 [22.445]

B:BD[22.3844] → [22.3844:3885]

            self.txn.get(db, key, value)

[22.3844]

[22.3885]

            if let Ok(x) = self.txn.get(db, key, value) {
                Ok(x)
            } else {
                Err(TxnErr(SanakirjaError::PristineCorrupt))
            }

Insertion in pijul-macros/src/lib.rs at line 133 [22.445]

[22.4509]

    let error = next(&mut input_iter);
    let error = if error.is_empty() {
        quote! { Error }
    } else {
        proc_macro2::TokenStream::from_iter(error.into_iter())
    };

Replacement in pijul-macros/src/lib.rs at line 141 [22.445]

B:BD[22.4594] → [22.4594:4709]

        #[doc(hidden)]
        fn #name_get<'txn>(&'txn self, key: #key, value: Option<#value>) -> Option<#value>;

[22.4594]

[22.4709]

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

Insertion in pijul-macros/src/lib.rs at line 157 [22.445]

[22.5398]

    let error = next(&mut input_iter);
    let error = if error.is_empty() {
        quote! { Error }
    } else {
        proc_macro2::TokenStream::from_iter(error.into_iter())
    };

Replacement in pijul-macros/src/lib.rs at line 165 [22.445]

B:BD[22.5483] → [22.5483:5624]

        #[doc(hidden)]
        fn #name_get<'txn>(&'txn self, db: &Self::#name_capital, key: #key, value: Option<#value>) -> Option<#value>;

[22.5483]

[22.5624]

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

Insertion in pijul-macros/src/lib.rs at line 234 [22.445]

[22.8021]


    let error = next(&mut input_iter);
    let error = if error.is_empty() {
        quote! { GraphError }
    } else {
        proc_macro2::TokenStream::from_iter(error.into_iter())
    };

Replacement in pijul-macros/src/lib.rs at line 244 [22.445]

B:BD[22.8069] → [22.8069:8160]

            crate::pristine::RevCursor<Self, &'txn Self, Self::#cursor_name, #key, #value>

[22.8069]

[22.8160]

            Result<crate::pristine::RevCursor<Self, &'txn Self, Self::#cursor_name, #key, #value>, TxnErr<Self::#error>>

Replacement in pijul-macros/src/lib.rs at line 248 [22.445]

B:BD[22.8200] → [22.8200:8288]

            crate::pristine::Cursor<Self, &'txn Self, Self::#cursor_name, #key, #value>

[22.8200]

[22.8288]

            Result<crate::pristine::Cursor<Self, &'txn Self, Self::#cursor_name, #key, #value>, TxnErr<Self::#error>>

Deletion in pijul-macros/src/lib.rs at line 255 [22.445]
B:BD[22.8376] → [22.8376:8403]
```
            #[doc(hidden)]
```
Deletion in pijul-macros/src/lib.rs at line 256 [22.445]
B:BD[22.8434] → [22.8434:8461]
```
            #[doc(hidden)]
```

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

B:BD[22.8573] → [22.8573:8641]

            ) -> Option<(#key, #value)>;
            #[doc(hidden)]

[22.8573]

[22.8641]

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

Replacement in pijul-macros/src/lib.rs at line 263 [22.445]

B:BD[22.8753] → [22.8753:8794]

            ) -> Option<(#key, #value)>;

[22.8753]

[22.8794]

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

Deletion in pijul-macros/src/lib.rs at line 268 [22.445]
B:BD[22.8857] → [22.8857:8880]
```
        #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 272 [22.445]

B:BD[22.9053] → [22.9053:9135]

        ) -> crate::pristine::Cursor<Self, RT, Self::#cursor_name, #key, #value>;

[22.9053]

[22.9135]

        ) -> Result<crate::pristine::Cursor<Self, RT, Self::#cursor_name, #key, #value>, TxnErr<Self::#error>>;

Deletion in pijul-macros/src/lib.rs at line 281 [22.445]
B:BD[22.9257] → [22.9257:9284]
```
            #[doc(hidden)]
```
Deletion in pijul-macros/src/lib.rs at line 291 [22.445]
B:BD[22.9552] → [22.9552:9575]
```
        #[doc(hidden)]
```
Deletion in pijul-macros/src/lib.rs at line 372 [22.445]
B:BD[22.12226] → [22.12226:12253]
```
            #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 376 [22.445]

B:BD[22.12375] → [22.12375:12460]

            ) -> super::Cursor<Self, &'txn Self, Self::#cursor_name, #key, #value> {

[22.12375]

[22.12460]

            ) -> Result<super::Cursor<Self, &'txn Self, Self::#cursor_name, #key, #value>, TxnErr<SanakirjaError>> {

Deletion in pijul-macros/src/lib.rs at line 386 [22.445]
B:BD[22.12630] → [22.12630:12657]
```
            #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 390 [22.445]

B:BD[22.12848] → [22.12848:12925]

            ) -> super::Cursor<Self, RT, Self::#cursor_name, #key, #value> {

[22.12848]

[22.12925]

            ) -> Result<super::Cursor<Self, RT, Self::#cursor_name, #key, #value>, TxnErr<SanakirjaError>> {

Replacement in pijul-macros/src/lib.rs at line 392 [22.445]

B:BD[22.12951] → [22.12951:13156]

                let mut cursor = txn.txn.set_cursors(&db, pos).0;
                super::Cursor {
                    cursor,
                    txn,
                    marker: std::marker::PhantomData,

[22.12951]

[22.13156]

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

Deletion in pijul-macros/src/lib.rs at line 409 [22.445]
B:BD[22.13310] → [22.13310:13337]
```
            #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 413 [22.445]

B:BD[22.13495] → [22.13495:13583]

            ) -> super::RevCursor<Self, &'txn Self, Self::#cursor_name, #key, #value> {

[22.13495]

[22.13583]

            ) -> Result<super::RevCursor<Self, &'txn Self, Self::#cursor_name, #key, #value>, TxnErr<SanakirjaError>> {

Replacement in pijul-macros/src/lib.rs at line 416 [22.445]

B:BD[22.13661] → [22.13661:13714]

                    self.txn.set_cursors(&db, pos).0

[22.13661]

[22.13714]

                    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

Replacement in pijul-macros/src/lib.rs at line 424 [22.445]

B:BD[22.13739] → [22.13739:13790]

                    self.txn.set_cursors_last(&db)

[22.13739]

[22.13790]

                    return Err(TxnErr(SanakirjaError::PristineCorrupt))

Replacement in pijul-macros/src/lib.rs at line 426 [22.445]
B:BD[22.13809] → [22.13809:13844]
```
                super::RevCursor {
```
[22.13809]
[22.13844]
```
                Ok(super::RevCursor {
```
Replacement in pijul-macros/src/lib.rs at line 430 [22.445]
B:BD[22.13957] → [22.13957:13975]
```
                }
```
[22.13957]
[22.13975]
```
                })
```
Deletion in pijul-macros/src/lib.rs at line 435 [22.445]
B:BD[22.14029] → [22.14029:14056]
```
            #[doc(hidden)]
```
Deletion in pijul-macros/src/lib.rs at line 436 [22.445]
B:BD[22.14109] → [22.14109:14136]
```
            #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 440 [22.445]

B:BD[22.14294] → [22.14294:14379]

            ) -> super::Cursor<Self, &'txn Self, Self::#cursor_name, #key, #value> {

[22.14294]

[22.14379]

            ) -> Result<super::Cursor<Self, &'txn Self, Self::#cursor_name, #key, #value>, TxnErr<SanakirjaError>> {

Replacement in pijul-macros/src/lib.rs at line 442 [22.445]

B:BD[22.14405] → [22.14405:14504]

                let mut cursor = self.txn.set_cursors(&db, pos).0;
                super::Cursor {

[22.14405]

[22.14504]

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

Replacement in pijul-macros/src/lib.rs at line 451 [22.445]
B:BD[22.14617] → [22.14617:14635]
```
                }
```
[22.14617]
[22.14635]
```
                })
```
Deletion in pijul-macros/src/lib.rs at line 454 [22.445]
B:BD[22.14669] → [22.14669:14696]
```
            #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 457 [22.445]

B:BD[22.14808] → [22.14808:14942]

            ) -> Option<(#key, #value)> {
                (unsafe { ::sanakirja::next(&self.txn, cursor) })
                    #post

[22.14808]

[22.14942]

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

Deletion in pijul-macros/src/lib.rs at line 465 [22.445]
B:BD[22.14956] → [22.14956:14983]
```
            #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 468 [22.445]

B:BD[22.15095] → [22.15095:15229]

            ) -> Option<(#key, #value)> {
                (unsafe { ::sanakirja::prev(&self.txn, cursor) })
                    #post

[22.15095]

[22.15229]

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

Insertion in pijul-macros/src/lib.rs at line 507 [22.445]

[22.16388]

    let txnt = next(&mut input_iter);
    let txnt: proc_macro2::TokenStream = if txnt.is_empty() {
        proc_macro2::TokenStream::from(quote! { TxnT })
    } else {
        proc_macro2::TokenStream::from_iter(txnt.into_iter())
    };
    let error = next(&mut input_iter);
    let error: proc_macro2::TokenStream = if error.is_empty() {
        proc_macro2::TokenStream::from(quote! { GraphError })
    } else {
        proc_macro2::TokenStream::from_iter(error.into_iter())
    };

Replacement in pijul-macros/src/lib.rs at line 524 [22.445]

B:BD[22.16490] → [22.16490:16627]

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

[22.16490]

[22.16627]

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

Replacement in pijul-macros/src/lib.rs at line 526 [22.445]

B:BD[22.16641] → [22.16641:16806]

                type Item = (#key, #value);
                fn next(&mut self) -> Option<(#key, #value)> {
                    self.txn.#name_prev(&mut self.cursor)

[22.16641]

[22.16806]

                type Item = Result<(#key, #value), TxnErr<T::#error>>;
                fn next(&mut self) -> Option<Self::Item> {
                    match self.txn.#name_prev(&mut self.cursor) {
                        Ok(Some(x)) => Some(Ok(x)),
                        Ok(None) => None,
                        Err(e) => Some(Err(e)),
                    }

Replacement in pijul-macros/src/lib.rs at line 539 [22.445]

B:BD[22.16910] → [22.16910:16969]

            impl<T: TxnT, RT: std::ops::Deref<Target = T>>

[22.16910]

[22.16969]

            impl<T: #txnt, RT: std::ops::Deref<Target = T>>

Replacement in pijul-macros/src/lib.rs at line 542 [22.445]

B:BD[22.17061] → [22.17061:17186]

                pub fn prev(&mut self) -> Option<(#key, #value)> {
                    self.txn.#name_prev(&mut self.cursor)

[22.17061]

[22.17186]

                pub fn prev(&mut self) -> Option<Result<(#key, #value), TxnErr<T::#error>>> {
                    match self.txn.#name_prev(&mut self.cursor) {
                        Ok(Some(x)) => Some(Ok(x)),
                        Ok(None) => None,
                        Err(e) => Some(Err(e)),
                    }

Replacement in pijul-macros/src/lib.rs at line 550 [22.445]

B:BD[22.17218] → [22.17218:17352]

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

[22.17218]

[22.17352]

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

Replacement in pijul-macros/src/lib.rs at line 552 [22.445]

B:BD[22.17366] → [22.17366:17531]

                type Item = (#key, #value);
                fn next(&mut self) -> Option<(#key, #value)> {
                    self.txn.#name_next(&mut self.cursor)

[22.17366]

[22.17531]

                type Item = Result<(#key, #value), TxnErr<T::#error>>;
                fn next(&mut self) -> Option<Self::Item> {
                    match self.txn.#name_next(&mut self.cursor) {
                        Ok(Some(x)) => Some(Ok(x)),
                        Ok(None) => None,
                        Err(e) => Some(Err(e)),
                    }

Insertion in pijul-macros/src/lib.rs at line 578 [22.445]

[22.18257]


    let error = next(&mut input_iter);
    let error = if error.is_empty() {
        quote! { Error }
    } else {
        proc_macro2::TokenStream::from_iter(error.into_iter())
    };

Deletion in pijul-macros/src/lib.rs at line 587 [22.445]
B:BD[22.18342] → [22.18342:18365]
```
        #[doc(hidden)]
```
Replacement in pijul-macros/src/lib.rs at line 591 [22.445]
B:BD[22.18449] → [23.0:40]
∅:D[23.40] → [22.18491:18514]
B:BD[22.18491] → [22.18491:18514]
```
        ) -> Result<bool, Self::Error>;
        #[doc(hidden)]
```
[22.18449]
[22.18514]
```
        ) -> Result<bool, TxnErr<Self::#error>>;
```
Replacement in pijul-macros/src/lib.rs at line 596 [22.445]
B:BD[22.18606] → [23.41:81]
```
        ) -> Result<bool, Self::Error>;
```
[22.18606]
[22.18648]
```
        ) -> Result<bool, TxnErr<Self::#error>>;
```

Insertion in pijul-macros/src/lib.rs at line 614 [22.445]

[22.19400]


    let error = next(&mut input_iter);
    let error = if error.is_empty() {
        quote! { Error }
    } else {
        proc_macro2::TokenStream::from_iter(error.into_iter())
    };

Insertion in pijul-macros/src/lib.rs at line 624 [22.445]
[22.19583]
[22.19583]
Insertion in pijul-macros/src/lib.rs at line 626 [22.445]
[22.19625]
[22.19625]
Deletion in pijul-macros/src/lib.rs at line 629 [22.445]
B:BD[22.19700] → [22.19700:19727]
```
            #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 633 [22.445]

B:BD[22.19827] → [23.82:127]

∅:D[23.127] → [22.19874:19946]

B:BD[22.19874] → [22.19874:19946]

            ) -> Result<bool, Self::Error> {
                Ok(self.txn.put(&mut self.rng, &mut self.#name, k, v)?)

[22.19827]

[22.19946]

            ) -> Result<bool, TxnErr<Self::#error>> {
                Ok(self.txn.put(&mut self.rng, &mut self.#name, k, v).map_err(TxnErr)?)

Deletion in pijul-macros/src/lib.rs at line 636 [22.445]
B:BD[22.19960] → [22.19960:19987]
```
            #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 640 [22.445]

B:BD[22.20095] → [23.128:173]

∅:D[23.173] → [22.20142:20214]

B:BD[22.20142] → [22.20142:20214]

            ) -> Result<bool, Self::Error> {
                Ok(self.txn.del(&mut self.rng, &mut self.#name, k, v)?)

[22.20095]

[22.20214]

            ) -> Result<bool, TxnErr<Self::#error>> {
                Ok(self.txn.del(&mut self.rng, &mut self.#name, k, v).map_err(TxnErr)?)

Deletion in pijul-macros/src/lib.rs at line 646 [22.445]
B:BD[22.20299] → [22.20299:20326]
```
            #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 650 [22.445]

B:BD[22.20426] → [23.174:219]

            ) -> Result<bool, Self::Error> {

[22.20426]

[22.20473]

            ) -> Result<bool, TxnErr<Self::#error>> {

Replacement in pijul-macros/src/lib.rs at line 653 [22.445]

B:BD[22.20543] → [22.20543:20615]

                Ok(self.txn.put(&mut self.rng, &mut self.#name, k, v)?)

[22.20543]

[22.20615]

                Ok(self.txn.put(&mut self.rng, &mut self.#name, k, v).map_err(TxnErr)?)

Deletion in pijul-macros/src/lib.rs at line 655 [22.445]
B:BD[22.20629] → [22.20629:20656]
```
            #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 659 [22.445]

B:BD[22.20764] → [23.220:265]

            ) -> Result<bool, Self::Error> {

[22.20764]

[22.20811]

            ) -> Result<bool, TxnErr<Self::#error>> {

Replacement in pijul-macros/src/lib.rs at line 662 [22.445]

B:BD[22.20892] → [22.20892:20964]

                Ok(self.txn.del(&mut self.rng, &mut self.#name, k, v)?)

[22.20892]

[22.20964]

                Ok(self.txn.del(&mut self.rng, &mut self.#name, k, v).map_err(TxnErr)?)

Replacement in pijul-macros/Cargo.toml at line 4 [22.21011]
B:BD[22.21091] → [24.0:18]
```
version = "0.2.0"
```
[22.21091]
[22.21109]
```
version = "0.3.0"
```
Insertion in pijul/src/repository.rs at line 4 [22.21431]
[22.21541]
[25.0]
```
use anyhow::bail;
```
Replacement in pijul/src/repository.rs at line 8 [22.21431]
B:BD[25.40] → [25.40:81]
```
use crate::{config, current_dir, Error};
```
[25.40]
[25.81]
```
use crate::{config, current_dir};
```

Replacement in pijul/src/repository.rs at line 45 [22.21431]

B:BD[22.22740] → [22.22740:22798]

                    return Err(Error::NoRepoRoot.into());

[22.22740]

[22.22798]

                    bail!("No Pijul repository found")

Replacement in pijul/src/repository.rs at line 74 [22.21431]

B:BD[22.23686] → [22.23686:23779]

                return Err((crate::Error::CouldNotReadConfig { path: config_path }).into());

[22.23686]

[22.23779]

                bail!("Could not read configuration file at {:?}", config_path)

Replacement in pijul/src/repository.rs at line 114 [22.21431]
B:BD[22.25296] → [22.25296:25342]
```
            Err(Error::AlreadyInARepo.into())
```
[22.25296]
[22.25342]
```
            bail!("Already in a repository")
```
Deletion in pijul/src/remote/ssh.rs at line 21 [22.25380]
B:BD[25.366] → [25.366:384]
```
use crate::Error;
```

Replacement in pijul/src/remote/ssh.rs at line 103 [22.25380]

B:BD[22.28303] → [22.28303:28359]

            return Err(Error::NotAuthenticated.into());

[22.28303]

[22.28359]

            bail!("Not authenticated")

Replacement in pijul/src/remote/ssh.rs at line 561 [22.25380]

B:BD[22.35811] → [22.35811:35977]

                        return Err((Error::RemoteExit {
                            status: exit_status,
                        })
                        .into());

[22.35811]

[22.35977]

                        bail!("Remote exited with status {:?}", exit_status)

Replacement in pijul/src/remote/ssh.rs at line 659 [22.25380]

B:BD[22.41652] → [22.41652:41834]

                            return Err((Error::RemoteExit {
                                status: exit_status,
                            })
                            .into());

[22.41652]

[22.41834]

                            bail!("Remote exited with status {:?}", exit_status)

Replacement in pijul/src/remote/ssh.rs at line 881 [22.25380]

B:BD[22.51533] → [22.51533:51588]

                let h = txn.get_external(ch).unwrap();

[22.51533]

[22.51716]

                let h = txn.get_external(ch)?.unwrap();

Replacement in pijul/src/remote/ssh.rs at line 885 [22.25380]

B:BD[22.51779] → [26.460:515]

B:BD[22.52027] → [22.52027:52059]

            for (_, (h, _)) in txn.log(&channel_, 0) {
                hashes.push(h);

[22.51779]

[22.52059]

            for h in txn.log(&channel_, 0)? {
                hashes.push((h?.1).0);

Deletion in pijul/src/remote/mod.rs at line 14 [22.52474]
B:BD[25.483] → [25.483:501]
```
use crate::Error;
```

Replacement in pijul/src/remote/mod.rs at line 75 [22.52474]

B:BD[22.54147] → [22.54147:54266]

            Err((Error::RemoteNotFound {
                remote: name.to_string(),
            })
            .into())

[22.54147]

[27.395]

            bail!("Remote not found: {:?}", name)

Replacement in pijul/src/remote/mod.rs at line 106 [22.52474]

B:BD[27.960] → [27.960:1063]

        Err((Error::RemoteNotFound {
            remote: name.to_string(),
        })
        .into())

[27.960]

[27.1063]

        bail!("Remote not found: {:?}", name)

Replacement in pijul/src/remote/mod.rs at line 181 [22.52474]

B:BD[22.57166] → [22.57166:57289]

            .iter_remote(&remote.borrow().remote, n)
            .filter_map(|(k, _)| if k >= n { Some(k) } else { None })

[22.57166]

[22.57289]

            .iter_remote(&remote.borrow().remote, n)?
            .filter_map(|k| {
                let k = k.unwrap().0;
                if k >= n {
                    Some(k)
                } else {
                    None
                }
            })

Replacement in pijul/src/remote/mod.rs at line 212 [22.52474]

B:BD[22.57695] → [22.57695:57775]

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

[22.57695]

[22.57775]

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

Replacement in pijul/src/remote/mod.rs at line 229 [22.52474]

B:BD[22.58358] → [22.58358:58438]

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

[22.58358]

[27.1790]

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

Replacement in pijul/src/remote/mod.rs at line 272 [22.52474]

B:BD[22.59915] → [22.59915:60067]

                    return Err((crate::Error::Http {
                        status: res.status(),
                    })
                    .into());

[22.59915]

[22.60067]

                    bail!("HTTP error {:?}", res.status())

Replacement in pijul/src/remote/mod.rs at line 288 [22.52474]

B:BD[27.1981] → [27.1981:2110]

                if let Some(channel) = txn.load_channel(&channel) {
                    Ok(local::get_state(txn, &channel, mid))

[27.1981]

[27.2110]

                if let Some(channel) = txn.load_channel(&channel)? {
                    local::get_state(txn, &channel, mid)

Replacement in pijul/src/remote/mod.rs at line 311 [22.52474]

B:BD[22.61331] → [22.61331:61408]

                    let mut channel = txn.load_channel(&l.channel).unwrap();

[22.61331]

[22.61408]

                    let mut channel = txn.load_channel(&l.channel)?.unwrap();

Replacement in pijul/src/remote/mod.rs at line 315 [22.52474]

B:BD[22.61584] → [22.61584:61657]

                    let channel = txn.load_channel(&l.channel).unwrap();

[22.61584]

[22.61657]

                    let channel = txn.load_channel(&l.channel)?.unwrap();

Replacement in pijul/src/remote/mod.rs at line 338 [22.52474]

B:BD[22.62677] → [22.62677:62829]

                    return Err((crate::Error::Http {
                        status: res.status(),
                    })
                    .into());

[22.62677]

[22.62829]

                    bail!("HTTP error {:?}", res.status())

Replacement in pijul/src/remote/mod.rs at line 595 [22.52474]

B:BD[22.73610] → [22.73610:73694]

            for (n, (h, s)) in txn.iter_rev_remote(&remote.borrow().remote, None) {

[22.73610]

[22.73694]

            for x in txn.iter_rev_remote(&remote.borrow().remote, None)? {
                let (n, (h, s)) = x?;

Replacement in pijul/src/remote/mod.rs at line 605 [22.52474]

B:BD[22.73931] → [22.73931:74000]

                return Err((Error::StateNotFound { state }).into());

[22.73931]

[22.74000]

                bail!("State not found: {:?}", state)

Replacement in pijul/src/remote/mod.rs at line 617 [22.52474]

B:BD[22.74338] → [22.74338:74411]

        for (n, (h, s)) in txn.iter_remote(&remote.borrow().remote, 0) {

[22.74338]

[22.74411]

        for x in txn.iter_remote(&remote.borrow().remote, 0)? {
            let (n, (h, s)) = x?;

Replacement in pijul/src/remote/mod.rs at line 627 [22.52474]

B:BD[22.74612] → [22.74612:74677]

            return Err((Error::StateNotFound { state }).into());

[22.74612]

[22.74677]

            bail!("State not found: {:?}", state)

Replacement in pijul/src/remote/mod.rs at line 659 [22.52474]

B:BD[22.76104] → [22.76104:76173]

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

[22.76104]

[22.76173]

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

Replacement in pijul/src/remote/mod.rs at line 669 [22.52474]

B:BD[22.76443] → [22.76443:76508]

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

[22.76443]

[22.76508]

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

Replacement in pijul/src/remote/mod.rs at line 681 [22.52474]

B:BD[22.76925] → [26.856:899]

            if txn.is_alive(&channel, v) {

[22.76925]

[26.899]

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

Replacement in pijul/src/remote/mod.rs at line 710 [22.52474]

B:BD[22.78339] → [22.78339:78420]

        for (_, (h, _)) in txn.iter_remote(&remote_changes.borrow().remote, 0) {

[22.78339]

[22.78420]

        for x in txn.iter_remote(&remote_changes.borrow().remote, 0)? {
            let (_, (h, _)) = x?;

Replacement in pijul/src/remote/local.rs at line 5 [22.79745]

B:BD[25.535] → [28.4235:4308]

∅:D[28.4308] → [22.79831:79868]

B:BD[22.79831] → [22.79831:79868]

use libpijul::pristine::{Base32, Hash, Merkle, MutTxnT, Position, TxnT};
use libpijul::{MutTxnTExt, TxnTExt};

[25.535]

[25.536]

use libpijul::pristine::{Hash, Merkle, MutTxnT, Position, TxnT};
use libpijul::*;

Replacement in pijul/src/remote/local.rs at line 24 [22.79745]
B:BD[27.3106] → [27.3106:3135]
```
) -> Option<(u64, Merkle)> {
```
[27.3106]
[27.3135]
```
) -> Result<Option<(u64, Merkle)>, anyhow::Error> {
```

Replacement in pijul/src/remote/local.rs at line 26 [22.79745]

B:BD[27.3164] → [27.3164:3226]

        txn.get_changes(&channel, mid).map(|(_, m)| (mid, m))

[27.3164]

[27.3226]

        Ok(txn.get_changes(&channel, mid)?.map(|(_, m)| (mid, m)))

Replacement in pijul/src/remote/local.rs at line 28 [22.79745]

B:BD[27.3239] → [27.3239:3347]

        txn.reverse_log(&channel.borrow(), None)
            .next()
            .map(|(n, (_, m))| (n, m))

[27.3239]

[27.3347]

        Ok(txn.reverse_log(&channel.borrow(), None)?.next().map(|n| {
            let (n, (_, m)) = n.unwrap();
            (n, m)
        }))

Replacement in pijul/src/remote/local.rs at line 38 [22.79745]

B:BD[22.80263] → [22.80263:80327]

B:BD[22.80327] → [27.3354:3397]

        let channel = txn.load_channel(&self.channel).unwrap();
        Ok(get_state(&txn, &channel, mid))

[22.80263]

[22.80598]

        let channel = txn.load_channel(&self.channel)?.unwrap();
        Ok(get_state(&txn, &channel, mid)?)

Replacement in pijul/src/remote/local.rs at line 51 [22.79745]

B:BD[22.80949] → [22.80949:81042]

        let remote_channel = if let Some(channel) = remote_txn.load_channel(&self.channel) {

[22.80949]

[22.81042]

        let remote_channel = if let Some(channel) = remote_txn.load_channel(&self.channel)? {

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

B:BD[28.4571] → [28.4571:4643]

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

[28.4571]

[28.4643]

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

Replacement in pijul/src/remote/local.rs at line 67 [22.79745]

B:BD[28.4729] → [28.4729:4919]

                paths_.extend(libpijul::fs::iter_graph_descendants(
                    &remote_txn,
                    &remote_channel.borrow(),
                    p,
                ));

[28.4729]

[22.81377]

                paths_.extend(
                    libpijul::fs::iter_graph_descendants(
                        &remote_txn,
                        &remote_channel.borrow().graph,
                        p,
                    )?
                    .map(|x| x.unwrap()),
                );

Replacement in pijul/src/remote/local.rs at line 78 [22.79745]

∅:D[28.4961] → [22.81401:81477]

B:BD[22.81401] → [22.81401:81477]

        for (n, (h, m)) in remote_txn.log(&remote_channel.borrow(), from) {

[28.4961]

[22.81477]

        for x in remote_txn.log(&remote_channel.borrow(), from)? {
            let (n, (h, m)) = x?;

Replacement in pijul/src/remote/local.rs at line 87 [22.79745]

B:BD[22.81705] → [22.81705:81770]

                let h_int = remote_txn.get_internal(h).unwrap();

[22.81705]

[22.81770]

                let h_int = remote_txn.get_internal(h)?.unwrap();

Replacement in pijul/src/remote/local.rs at line 89 [22.79745]

B:BD[22.81807] → [22.81807:81959]

                    || paths_
                        .iter()
                        .any(|x| remote_txn.get_touched_files(*x, Some(h_int)).is_some())

[22.81807]

[22.81959]

                    || paths_.iter().any(|x| {
                        remote_txn
                            .get_touched_files(*x, Some(h_int))
                            .unwrap()
                            .is_some()
                    })

Insertion in pijul/src/remote/http.rs at line 5 [30.10]
[29.1193]
[29.1193]
```
use anyhow::bail;
```

Replacement in pijul/src/remote/http.rs at line 44 [30.10]

∅:D[20.240] → [31.1063:1183]

B:BD[31.1063] → [31.1063:1183]

            return Err((crate::Error::Http {
                status: res.status(),
            })
            .into());

[20.240]

[31.1183]

            bail!("HTTP error {:?}", res.status())

Replacement in pijul/src/remote/http.rs at line 183 [30.10]

B:BD[28.5693] → [28.5693:5813]

            return Err((crate::Error::Http {
                status: res.status(),
            })
            .into());

[28.5693]

[28.5813]

            bail!("HTTP error {:?}", res.status())

Insertion in pijul/src/main.rs at line 10 [22.83981]
[25.603]
[32.0]
```
use anyhow::bail;
```
Deletion in pijul/src/main.rs at line 13 [22.83981]
B:BD[25.716] → [33.0:32]
B:BD[33.32] → [26.1637:1659]
```
use libpijul::pristine::Base32;
use thiserror::Error;
```

Deletion in pijul/src/main.rs at line 125 [22.83981]

∅:D[4.98] → [22.85867:86849]

B:BD[22.85867] → [22.85867:86849]

B:BD[22.86917] → [22.86917:87334]

B:BD[22.87413] → [22.87413:87666]

B:BD[22.87666] → [25.867:909]

∅:D[25.909] → [22.87719:87776]

B:BD[22.87719] → [22.87719:87776]

B:BD[22.87776] → [34.0:82]

∅:D[34.82] → [22.87776:88054]

B:BD[22.87776] → [22.87776:88054]

B:BD[35.93] → [33.33:133]

B:BD[33.133] → [26.1660:1751]

}
#[derive(Debug, Error)]
pub enum Error {
    #[error("No Pijul repository found")]
    NoRepoRoot,
    #[error("Cannot access working directory")]
    CannotAccessWorkingDirectory,
    #[error("Already in a repository")]
    AlreadyInARepo,
    #[error("No such channel: {}", channel)]
    NoSuchChannel { channel: String },
    #[error("Protocol error. Is this the correct URL?")]
    ProtocolError { line: Vec<u8> },
    #[error("Not authenticated")]
    NotAuthenticated,
    #[error("No change message")]
    NoChangeMessage,
    #[error("Incorrect remote: {}", name)]
    IncorrectRemote { name: String },
    #[error("Unknown host key")]
    UnknownHostKey,
    #[error("Cannot record a binary change interactively. Use -a")]
    RecordBinaryChange,
    #[error("Remote not found: {:?}", remote)]
    RemoteNotFound { remote: String },
    #[error("No global config directory")]
    NoGlobalConfigDir,
    #[error("Could not parse global config")]
    CouldNotParseGlobal,
    #[error("Remote error: {}", msg)]
    Remote { msg: String },
    #[error("Remote exited with status {}", status)]
    RemoteExit { status: u32 },
    #[error("Missing remote")]
    MissingRemote,
    #[error("State not found in remote: {:?}", state)]
    StateNotFound { state: libpijul::pristine::Merkle },
    #[error("Missing dependencies for change {:?}", h)]
    MissingDep { h: libpijul::pristine::Hash },
    #[error("No prefixes given. Use `.` to record the current directory.")]
    NoRecordPrefixes,
    #[error("HTTP error: {}", status.as_str())]
    Http { status: reqwest::StatusCode },
    #[error("Could not parse configuration file at {:?}", path)]
    CouldNotReadConfig { path: PathBuf },
    #[error("No current channel")]
    NoCurrentChannel,
    #[error("Cannot delete the current channel")]
    CannotDeleteCurrentChannel,
    #[error("Channel not found: {:?}", channel)]
    ChannelNotFound { channel: String },
    #[error("Cannot reset, because there are unrecorded changes")]
    UnrecordedChanges,
    #[error("Could not infer repository name")]
    CouldNotInferRepositoryName { repo: String },
    #[error("Cannot unrecord change {}, because change {} depends on it", change, dep.to_base32())]
    CannotUnrecord {
        change: String,
        dep: libpijul::pristine::Hash,
    },

Replacement in pijul/src/main.rs at line 207 [22.83981]

B:BD[22.89714] → [25.910:959]

∅:D[25.959] → [22.89774:89851]

B:BD[22.89774] → [22.89774:89851]

pub fn current_dir() -> Result<PathBuf, Error> {
    std::env::current_dir().map_err(|_| Error::CannotAccessWorkingDirectory)

[22.89714]

[22.89851]

pub fn current_dir() -> Result<PathBuf, anyhow::Error> {
    if let Ok(cur) = std::env::current_dir() {
        Ok(cur)
    } else {
        bail!("Cannot access working directory")
    }

Deletion in pijul/src/config.rs at line 1 [22.89866]
B:BD[22.89866] → [7.0:19]
```
use crate::Error;
```
Insertion in pijul/src/config.rs at line 3 [22.89866]
[22.89899]
[25.960]
```
use anyhow::bail;
```

Replacement in pijul/src/config.rs at line 42 [22.89866]

B:BD[22.90697] → [7.701:794]

            toml::from_slice(&s).map_err(|_| Error::CouldNotReadConfig { path: dir }.into())

[22.90697]

[22.90881]

            if let Ok(t) = toml::from_slice(&s) {
                Ok(t)
            } else {
                bail!("Could not read configuration file at {:?}", dir)
            }

Replacement in pijul/src/config.rs at line 48 [22.89866]

B:BD[22.90898] → [7.795:844]

            Err(Error::NoGlobalConfigDir.into())

[22.90898]

[22.90954]

            bail!("Global configuration file missing")

Replacement in pijul/src/commands/unrecord.rs at line 7 [22.95630]
B:BD[36.59] → [37.900:960]
```
use libpijul::{Base32, MutTxnT, MutTxnTExt, TxnT, TxnTExt};
```
[36.59]
[25.1235]
```
use libpijul::*;
```

Replacement in pijul/src/commands/unrecord.rs at line 39 [22.95630]

B:BD[22.96409] → [33.246:314]

        if let Some(mut channel) = txn.load_channel(channel_name) {

[22.96409]

[36.314]

        if let Some(mut channel) = txn.load_channel(channel_name)? {

Replacement in pijul/src/commands/unrecord.rs at line 63 [22.95630]

B:BD[37.2290] → [37.2290:2390]

                    .reverse_log(&channel.borrow(), None)
                    .map(|(_, (h, _))| h)

[37.2290]

[37.2390]

                    .reverse_log(&channel.borrow(), None)?
                    .map(|h| (h.unwrap().1).0)

Replacement in pijul/src/commands/unrecord.rs at line 88 [22.95630]

B:BD[22.96722] → [22.96722:96781]

                for (p, d) in txn.iter_revdep(change_id) {

[22.96722]

[22.96781]

                for p in txn.iter_revdep(change_id)? {
                    let (p, d) = p?;

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

B:BD[22.96953] → [22.96953:97034]

B:BD[22.97034] → [36.487:551]

                    if txn.get_changeset(&channel_.changes, d, None).is_some() {
                        let dep = txn.get_external(d).unwrap();

[22.96953]

[36.551]

                    if txn.get_changeset(&channel_.changes, d, None)?.is_some() {
                        let dep = txn.get_external(d)?.unwrap();

Deletion in pijul/src/commands/reset.rs at line 10 [22.97650]
B:BD[25.1383] → [25.1383:1401]
```
use crate::Error;
```

Replacement in pijul/src/commands/reset.rs at line 41 [22.97650]

∅:D[18.108] → [22.98455:98538]

B:BD[22.98455] → [22.98455:98538]

        let mut channel = if let Some(channel) = txn.load_channel(&channel_name) {

[18.108]

[22.98538]

        let mut channel = if let Some(channel) = txn.load_channel(&channel_name)? {

Replacement in pijul/src/commands/reset.rs at line 44 [22.97650]

B:BD[22.98672] → [22.98672:98807]

            return Err((Error::NoSuchChannel {
                channel: channel_name.to_string(),
            })
            .into());

[22.98672]

[22.98807]

            bail!("No such channel: {:?}", channel_name)

Replacement in pijul/src/commands/reset.rs at line 75 [22.97650]

∅:D[34.934] → [22.99838:99917]

B:BD[22.99838] → [22.99838:99917]

                if let Some(mut channel) = txn.load_channel(current_channel) {

[34.934]

[22.99917]

                if let Some(mut channel) = txn.load_channel(current_channel)? {

Replacement in pijul/src/commands/reset.rs at line 88 [22.97650]

B:BD[22.100440] → [22.100440:100509]

                        return Err(Error::UnrecordedChanges.into());

[22.100440]

[22.100509]

                        bail!("Cannot change channel, as there are unrecorded changes.")

Insertion in pijul/src/commands/record.rs at line 5 [22.101759]
[25.1486]
[38.25]
```
use anyhow::bail;
```
Deletion in pijul/src/commands/record.rs at line 17 [22.101759]
B:BD[25.1600] → [25.1600:1618]
```
use crate::Error;
```

Replacement in pijul/src/commands/record.rs at line 76 [22.101759]

B:BD[2.174] → [2.174:288]

            } else if let Some((_, (h, _))) = txn.reverse_log(&channel.borrow(), None).next() {
                h

[2.174]

[2.288]

            } else if let Some(h) = txn.reverse_log(&channel.borrow(), None)?.next() {
                (h?.1).0

Replacement in pijul/src/commands/record.rs at line 200 [22.101759]
B:BD[22.107689] → [22.107689:107732]
```
            .map(|rec| rec.globalize(txn))
```
[22.107689]
[22.107732]
```
            .map(|rec| rec.globalize(txn).unwrap())
```

Replacement in pijul/src/commands/record.rs at line 203 [22.101759]

B:BD[22.107777] → [22.107777:107872]

            LocalChange::make_change(txn, channel, actions, rec.contents, header, Vec::new());

[22.107777]

[22.107872]

            LocalChange::make_change(txn, channel, actions, rec.contents, header, Vec::new())?;

Replacement in pijul/src/commands/record.rs at line 210 [22.101759]

B:BD[22.108130] → [22.108130:108188]

            return Err(Error::RecordBinaryChange.into());

[22.108130]

[22.108188]

            bail!("Cannot record a binary change interactively. Please use -a.")

Replacement in pijul/src/commands/record.rs at line 243 [22.101759]
B:BD[22.109346] → [22.109346:109401]
```
            return Err(Error::NoChangeMessage.into());
```
[22.109346]
[22.109401]
```
            bail!("No change message")
```
Replacement in pijul/src/commands/pushpull.rs at line 10 [22.111631]
B:BD[22.111707] → [26.2331:2383]
```
use libpijul::{MutTxnT, MutTxnTExt, TxnT, TxnTExt};
```
[22.111707]
[25.1743]
```
use libpijul::*;
```

Replacement in pijul/src/commands/pushpull.rs at line 40 [22.111631]

B:BD[22.112523] → [22.112523:112571]

                for r in txn.iter_remotes("") {

[22.112523]

[22.112571]

                for r in txn.iter_remotes("")? {
                    let r = r?;

Replacement in pijul/src/commands/pushpull.rs at line 165 [22.111631]

B:BD[28.7290] → [28.7290:7445]

            paths.extend(libpijul::fs::iter_graph_descendants(
                &txn,
                &channel.borrow(),
                p,
            ));

[28.7290]

[28.7445]

            paths.extend(
                libpijul::fs::iter_graph_descendants(&txn, &channel.borrow().graph, p)?
                    .map(|x| x.unwrap()),
            );

Replacement in pijul/src/commands/pushpull.rs at line 172 [22.111631]

B:BD[22.116268] → [22.116268:116338]

        for (_, (h, m)) in txn.reverse_log(&channel.borrow(), None) {

[22.116268]

[28.7456]

        for x in txn.reverse_log(&channel.borrow(), None)? {
            let (_, (h, m)) = x?;

Replacement in pijul/src/commands/pushpull.rs at line 175 [22.111631]

∅:D[28.7524] → [27.4561:4622]

B:BD[27.4561] → [27.4561:4622]

                if txn.remote_has_state(remote_changes, m) {

[28.7524]

[27.4622]

                if txn.remote_has_state(remote_changes, m)? {

Replacement in pijul/src/commands/pushpull.rs at line 178 [22.111631]

B:BD[27.4667] → [27.4667:4789]

                let h_int = txn.get_internal(h).unwrap();
                if !txn.remote_has_change(&remote_changes, h) {

[27.4667]

[28.7525]

                let h_int = txn.get_internal(h)?.unwrap();
                if !txn.remote_has_change(&remote_changes, h)? {

Replacement in pijul/src/commands/pushpull.rs at line 184 [22.111631]

B:BD[28.7686] → [28.7686:7768]

                            if txn.get_touched_files(*p, Some(h_int)).is_some() {

[28.7686]

[28.7768]

                            if txn.get_touched_files(*p, Some(h_int))?.is_some() {

Replacement in pijul/src/commands/pushpull.rs at line 192 [22.111631]

B:BD[27.5132] → [27.5132:5206]

                if let Some(channel) = txn.load_channel(remote_channel) {

[27.5132]

[27.5206]

                if let Some(channel) = txn.load_channel(remote_channel)? {

Replacement in pijul/src/commands/pushpull.rs at line 194 [22.111631]

B:BD[27.5258] → [27.5258:5404]

                    let h_int = txn.get_internal(h).unwrap();
                    if txn.get_changeset(&channel.changes, h_int, None).is_none() {

[27.5258]

[28.7889]

                    let h_int = txn.get_internal(h)?.unwrap();
                    if txn.get_changeset(&channel.changes, h_int, None)?.is_none() {

Replacement in pijul/src/commands/pushpull.rs at line 200 [22.111631]

B:BD[28.8066] → [28.8066:8152]

                                if txn.get_touched_files(*p, Some(h_int)).is_some() {

[28.8066]

[28.8152]

                                if txn.get_touched_files(*p, Some(h_int))?.is_some() {

Replacement in pijul/src/commands/pushpull.rs at line 309 [22.111631]

∅:D[28.8812] → [27.6267:6416]

B:BD[27.6267] → [27.6267:6416]

                for (_, (h, m)) in txn.iter_remote(&remote_changes.borrow().remote, 0) {
                    if txn.channel_has_state(&channel, m) {

[28.8812]

[27.6416]

                for x in txn.iter_remote(&remote_changes.borrow().remote, 0)? {
                    let (h, m) = x?.1;
                    if txn.channel_has_state(&channel, m)? {

Replacement in pijul/src/commands/pushpull.rs at line 313 [22.111631]

B:BD[27.6447] → [27.6447:6521]

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

[27.6447]

[27.6521]

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

Replacement in pijul/src/commands/pushpull.rs at line 325 [22.111631]

B:BD[28.9108] → [28.9108:9305]

                    inodes_.extend(libpijul::fs::iter_graph_descendants(
                        &txn,
                        &channel.borrow(),
                        p,
                    ));

[28.9108]

[28.9305]

                    inodes_.extend(
                        libpijul::fs::iter_graph_descendants(&txn, &channel.borrow().graph, p)?
                            .map(|x| x.unwrap()),
                    );

Replacement in pijul/src/commands/pushpull.rs at line 331 [22.111631]

B:BD[28.9407] → [28.9407:9472]

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

[28.9407]

[28.9472]

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

Replacement in pijul/src/commands/pushpull.rs at line 334 [22.111631]

∅:D[28.9525] → [27.7112:7193]

B:BD[27.7112] → [27.7112:7193]

                if let Some(remote_channel) = txn.load_channel(remote_channel) {

[28.9525]

[27.7193]

                if let Some(remote_channel) = txn.load_channel(remote_channel)? {

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

B:BD[27.7259] → [27.7259:7403]

                    for (_, (h, m)) in txn.reverse_log(&remote_channel, None) {
                        if txn.channel_has_state(&channel, m) {

[27.7259]

[27.7403]

                    for x in txn.reverse_log(&remote_channel, None)? {
                        let (h, m) = x?.1;
                        if txn.channel_has_state(&channel, m)? {

Replacement in pijul/src/commands/pushpull.rs at line 341 [22.111631]

B:BD[27.7464] → [27.7464:7530]

                        let h_int = txn.get_internal(h).unwrap();

[27.7464]

[27.7530]

                        let h_int = txn.get_internal(h)?.unwrap();

Replacement in pijul/src/commands/pushpull.rs at line 343 [22.111631]

B:BD[27.7561] → [27.7561:7644]

                            .get_changeset(&channel.borrow().changes, h_int, None)

[27.7561]

[27.7644]

                            .get_changeset(&channel.borrow().changes, h_int, None)?

Replacement in pijul/src/commands/pushpull.rs at line 348 [22.111631]

B:BD[28.9641] → [28.9641:9733]

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

[28.9641]

[28.9733]

                                    txn.get_rev_touched_files(h_int, Some(inode))
                                        .unwrap()
                                        .is_some()

Replacement in pijul/src/commands/pushpull.rs at line 436 [22.111631]

B:BD[28.10482] → [28.10482:10557]

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

[28.10482]

[28.10557]

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

Replacement in pijul/src/commands/pushpull.rs at line 488 [22.111631]

B:BD[15.350] → [15.350:401]

                if txn.remote_has_change(rem, d) {

[15.350]

[15.401]

                if txn.remote_has_change(rem, d)? {

Insertion in pijul/src/commands/protocol.rs at line 6 [22.123281]
[25.1914]
[22.123335]
```
use crate::repository::Repository;
use anyhow::bail;
```
Replacement in pijul/src/commands/protocol.rs at line 11 [22.123281]
B:BD[25.1961] → [26.3000:3078]
```
use libpijul::{Base32, ChannelRef, Hash, MutTxnT, MutTxnTExt, TxnT, TxnTExt};
```
[25.1961]
[25.1962]
```
use libpijul::*;
```
Deletion in pijul/src/commands/protocol.rs at line 15 [22.123281]
B:BD[25.1989] → [25.1989:2042]
∅:D[25.2042] → [22.123610:123611]
B:BD[22.123610] → [22.123610:123611]
```
use crate::repository::Repository;
use crate::Error;
```

Replacement in pijul/src/commands/protocol.rs at line 38 [22.123281]

B:BD[22.124435] → [26.3079:3165]

∅:D[26.3165] → [22.124518:124564]

B:BD[22.124518] → [22.124518:124564]

fn load_channel<T: MutTxnTExt>(txn: &T, name: &str) -> Result<ChannelRef<T>, Error> {
    if let Some(c) = txn.load_channel(name) {

[22.124435]

[22.124564]

fn load_channel<T: MutTxnTExt>(txn: &T, name: &str) -> Result<ChannelRef<T>, anyhow::Error> {
    if let Some(c) = txn.load_channel(name)? {

Replacement in pijul/src/commands/protocol.rs at line 42 [22.123281]
B:BD[22.124591] → [39.837:872]
∅:D[39.872] → [22.124627:124677]
B:BD[22.124627] → [22.124627:124677]
```
        Err(Error::NoSuchChannel {
            channel: name.to_string(),
        })
```
[22.124591]
[22.124694]
```
        bail!("No such channel: {:?}", name)
```

Replacement in pijul/src/commands/protocol.rs at line 72 [22.123281]

B:BD[22.125737] → [22.125737:125810]

                    for (n, (_, m)) in txn.log(&channel.borrow(), pos) {

[22.125737]

[39.922]

                    for x in txn.log(&channel.borrow(), pos)? {
                        let (n, (_, m)) = x?;

Replacement in pijul/src/commands/protocol.rs at line 86 [22.123281]

B:BD[22.126196] → [39.1415:1515]

                } else if let Some((n, (_, m))) = txn.reverse_log(&channel.borrow(), None).next() {

[22.126196]

[39.1515]

                } else if let Some(x) = txn.reverse_log(&channel.borrow(), None)?.next() {
                    let (n, (_, m)) = x?;

Replacement in pijul/src/commands/protocol.rs at line 103 [22.123281]

B:BD[22.127036] → [22.127036:127231]

                            return Err((Error::ProtocolError {
                                line: buf.as_bytes().to_vec(),
                            })
                            .into());

[22.127036]

[22.127231]

                            bail!("Ambiguous path")

Replacement in pijul/src/commands/protocol.rs at line 105 [22.123281]

B:BD[22.127257] → [28.11485:11554]

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

[22.127257]

[28.11554]

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

Replacement in pijul/src/commands/protocol.rs at line 108 [22.123281]

B:BD[28.11666] → [28.11666:11881]

                        paths.extend(libpijul::fs::iter_graph_descendants(
                            &txn,
                            &channel.borrow(),
                            p,
                        ));

[28.11666]

[22.127295]

                        paths.extend(
                            libpijul::fs::iter_graph_descendants(&txn, &channel.borrow().graph, p)?
                                .map(|x| x.unwrap()),
                        );

Replacement in pijul/src/commands/protocol.rs at line 113 [22.123281]

B:BD[22.127324] → [22.127324:127503]

                        return Err((Error::ProtocolError {
                            line: buf.as_bytes().to_vec(),
                        })
                        .into());

[22.127324]

[22.127503]

                        debug!("protocol line: {:?}", buf);
                        bail!("Protocol error")

Replacement in pijul/src/commands/protocol.rs at line 118 [22.123281]

∅:D[28.11929] → [22.127543:127675]

B:BD[22.127543] → [22.127543:127675]

                for (n, (h, m)) in txn.log(&channel.borrow(), from) {
                    let h_int = txn.get_internal(h).unwrap();

[28.11929]

[22.127675]

                for x in txn.log(&channel.borrow(), from)? {
                    let (n, (h, m)) = x?;
                    let h_int = txn.get_internal(h)?.unwrap();

Replacement in pijul/src/commands/protocol.rs at line 123 [22.123281]

B:BD[28.11980] → [28.11980:12078]

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

[28.11980]

[28.12078]

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

Replacement in pijul/src/commands/protocol.rs at line 137 [22.123281]

B:BD[22.128296] → [22.128296:128459]

                    return Err((Error::ProtocolError {
                        line: buf.as_bytes().to_vec(),
                    })
                    .into());

[22.128296]

[22.128459]

                    debug!("protocol error: {:?}", buf);
                    bail!("Protocol error")

Replacement in pijul/src/commands/protocol.rs at line 168 [22.123281]

B:BD[22.129776] → [22.129776:129939]

                    return Err((Error::ProtocolError {
                        line: buf.as_bytes().to_vec(),
                    })
                    .into());

[22.129776]

[22.129939]

                    debug!("protocol error {:?}", buf);
                    bail!("Protocol error");

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

B:BD[22.130748] → [22.130748:130875]

                for d in libpijul::pristine::channel_dump::dump_channel(&txn, channel) {
                    o.write_all(&d)?;

[22.130748]

[22.130875]

                for d in libpijul::pristine::channel_dump::dump_channel(&txn, channel)? {
                    o.write_all(&d?)?;

Replacement in pijul/src/commands/protocol.rs at line 201 [22.123281]

B:BD[22.131779] → [16.0:91]

                    if txn.current_state(&channel.borrow()) == state && extra.is_empty() {

[22.131779]

[22.131876]

                    if txn.current_state(&channel.borrow())? == state && extra.is_empty() {

Replacement in pijul/src/commands/mod.rs at line 80 [22.133619]
B:BD[36.2244] → [36.2244:2283]
```
        .map(|rec| rec.globalize(txn))
```
[36.2244]
[36.2283]
```
        .map(|rec| rec.globalize(txn).unwrap())
```
Replacement in pijul/src/commands/mod.rs at line 89 [22.133619]
B:BD[36.2516] → [36.2516:2523]
```
    );
```
[36.2516]
[36.2523]
```
    )?;
```

Replacement in pijul/src/commands/mod.rs at line 91 [22.133619]

B:BD[36.2561] → [36.2561:2646]

        libpijul::change::dependencies(txn, channel, pending_change.changes.iter());

[36.2561]

[36.2646]

        libpijul::change::dependencies(txn, &channel.borrow(), pending_change.changes.iter())?;

Insertion in pijul/src/commands/log.rs at line 4 [22.134376]
[25.2088]
[25.2088]
```
use anyhow::bail;
```
Deletion in pijul/src/commands/log.rs at line 10 [22.134376]
B:BD[25.2141] → [25.2141:2159]
```
use crate::Error;
```

Replacement in pijul/src/commands/log.rs at line 35 [22.134376]

B:BD[22.135173] → [22.135173:135251]

        let channel = if let Some(channel) = txn.load_channel(channel_name) {

[22.135173]

[22.135251]

        let channel = if let Some(channel) = txn.load_channel(channel_name)? {

Replacement in pijul/src/commands/log.rs at line 38 [22.134376]

B:BD[22.135288] → [22.135288:135423]

            return Err((Error::NoSuchChannel {
                channel: channel_name.to_string(),
            })
            .into());

[22.135288]

[22.135423]

            bail!("No such channel: {:?}", channel_name)

Replacement in pijul/src/commands/log.rs at line 44 [22.134376]

B:BD[22.135542] → [9.0:74]

            for (_, (h, _)) in txn.reverse_log(&channel.borrow(), None) {

[22.135542]

[22.135619]

            for h in txn.reverse_log(&channel.borrow(), None)? {
                let h = (h?.1).0;

Replacement in pijul/src/commands/log.rs at line 50 [22.134376]

B:BD[22.135743] → [22.135743:135819]

            for (_, (h, mrk)) in txn.reverse_log(&channel.borrow(), None) {

[22.135743]

[14.0]

            for h in txn.reverse_log(&channel.borrow(), None)? {
                let (h, mrk) = h?.1;

Replacement in pijul/src/commands/fork.rs at line 35 [22.167873]

B:BD[22.168851] → [22.168851:168919]

            if let Some(channel) = txn.load_channel(channel_name) {

[22.168851]

[22.168919]

            if let Some(channel) = txn.load_channel(channel_name)? {

Replacement in pijul/src/commands/file_operations.rs at line 81 [22.169058]

B:BD[22.171069] → [22.171069:171117]

        for (_, p) in txn.iter_working_copy() {

[22.171069]

[22.171117]

        for p in txn.iter_working_copy() {
            let p = p?.1;

Replacement in pijul/src/commands/file_operations.rs at line 140 [22.169058]

B:BD[40.891] → [40.891:939]

                if !txn.is_tracked(&path_str) {

[40.891]

[17.660]

                if !txn.is_tracked(&path_str)? {

Replacement in pijul/src/commands/file_operations.rs at line 184 [22.169058]
B:BD[22.173382] → [22.173382:173425]
```
            if txn.is_tracked(&path_str) {
```
[22.173382]
[22.173425]
```
            if txn.is_tracked(&path_str)? {
```
Replacement in pijul/src/commands/diff.rs at line 71 [22.173551]
B:BD[22.175217] → [22.175217:175261]
```
            .map(|rec| rec.globalize(&txn))
```
[22.175217]
[22.175261]
```
            .map(|rec| rec.globalize(&txn).unwrap())
```
Replacement in pijul/src/commands/diff.rs at line 80 [22.173551]
B:BD[22.175484] → [22.175484:175495]
```
        );
```
[22.175484]
[22.175495]
```
        )?;
```
Replacement in pijul/src/commands/diff.rs at line 83 [22.173551]
B:BD[22.175552] → [22.175552:175598]
```
            full_dependencies(&txn, &channel)
```
[22.175552]
[22.175598]
```
            full_dependencies(&txn, &channel)?
```

Replacement in pijul/src/commands/diff.rs at line 85 [22.173551]

B:BD[22.175615] → [22.175615:175679]

            dependencies(&txn, &channel, change.changes.iter())

[22.175615]

[22.175679]

            dependencies(&txn, &channel.borrow(), change.changes.iter())?

Replacement in pijul/src/commands/debug.rs at line 4 [22.177758]
B:BD[22.177794] → [22.177794:177812]
```
use crate::Error;
```
[22.177794]
[41.0]
```
use anyhow::bail;
```

Replacement in pijul/src/commands/debug.rs at line 26 [22.177758]

B:BD[22.178297] → [22.178297:178376]

        let channel = if let Some(channel) = txn.load_channel(&channel_name) {

[22.178297]

[22.178376]

        let channel = if let Some(channel) = txn.load_channel(&channel_name)? {

Replacement in pijul/src/commands/debug.rs at line 29 [22.177758]

B:BD[22.178413] → [22.178413:178548]

            return Err((Error::NoSuchChannel {
                channel: channel_name.to_string(),
            })
            .into());

[22.178413]

[22.178548]

            bail!("No such channel: {:?}", channel_name)

Replacement in pijul/src/commands/debug.rs at line 37 [22.177758]
B:BD[42.264] → [42.264:299]
```
                &channel.borrow(),
```
[42.264]
[42.299]
```
                &channel.borrow().graph,
```

Replacement in pijul/src/commands/debug.rs at line 44 [22.177758]

B:BD[43.102] → [43.102:177]

            libpijul::pristine::debug(&txn, &channel, std::io::stdout())?;

[43.102]

[43.177]

            libpijul::pristine::debug(&txn, &channel.graph, std::io::stdout())?;

Replacement in pijul/src/commands/debug.rs at line 46 [22.177758]

B:BD[43.187] → [43.187:269]

        libpijul::pristine::check_alive_debug(&repo.changes, &txn, &channel, 0)?;

[43.187]

[19.0]

        libpijul::pristine::check_alive_debug(&repo.changes, &txn, &channel.borrow(), 0)?;

Insertion in pijul/src/commands/credit.rs at line 4 [22.178684]
[25.2811]
[18.690]
```
use anyhow::bail;
```
Replacement in pijul/src/commands/credit.rs at line 8 [22.178684]
B:BD[22.178851] → [26.5891:5960]
```
use libpijul::{ChangeId, Channel, EdgeFlags, TxnT, TxnTExt, Vertex};
```
[22.178851]
[25.2828]
```
use libpijul::*;
```
Deletion in pijul/src/commands/credit.rs at line 12 [22.178684]
B:BD[25.2880] → [25.2880:2898]
```
use crate::Error;
```

Replacement in pijul/src/commands/credit.rs at line 31 [22.178684]

B:BD[22.179431] → [22.179431:179510]

        let channel = if let Some(channel) = txn.load_channel(&channel_name) {

[22.179431]

[22.179510]

        let channel = if let Some(channel) = txn.load_channel(&channel_name)? {

Replacement in pijul/src/commands/credit.rs at line 34 [22.178684]

B:BD[22.179547] → [22.179547:179682]

            return Err((Error::NoSuchChannel {
                channel: channel_name.to_string(),
            })
            .into());

[22.179547]

[22.179682]

            bail!("No such channel: {:?}", channel_name)

Replacement in pijul/src/commands/credit.rs at line 64 [22.178684]
B:BD[22.180479] → [26.5961:6018]
```
pub struct Creditor<'a, W: std::io::Write, T: TxnTExt> {
```
[22.180479]
[22.180533]
```
pub struct Creditor<'a, W: std::io::Write, T: ChannelTxnT> {
```

Replacement in pijul/src/commands/credit.rs at line 73 [22.178684]

B:BD[22.180661] → [26.6019:6080]

impl<'a, W: std::io::Write, T: TxnTExt> Creditor<'a, W, T> {

[22.180661]

[22.180719]

impl<'a, W: std::io::Write, T: ChannelTxnT> Creditor<'a, W, T> {

Deletion in pijul/src/commands/credit.rs at line 99 [22.178684]
B:BD[22.181319] → [26.6160:6190]
```
        use libpijul::Base32;
```
Replacement in pijul/src/commands/credit.rs at line 104 [22.178684]
B:BD[22.181558] → [44.0:56]
```
                .filter(|e| !e.introduced_by.is_root())
```
[22.181558]
[22.181558]
```
                .unwrap()
```

Insertion in pijul/src/commands/credit.rs at line 106 [22.178684]

[22.181572]

                let e = e.unwrap();
                if e.introduced_by.is_root() {
                    continue;
                }

Insertion in pijul/src/commands/clone.rs at line 4 [22.182891]
[25.2925]
[25.2925]
```
use crate::repository::*;
use anyhow::bail;
```
Deletion in pijul/src/commands/clone.rs at line 10 [22.182891]
B:BD[22.183024] → [25.2959:2986]
```
use crate::repository::*;
```

Replacement in pijul/src/commands/clone.rs at line 57 [22.182891]

B:BD[22.184404] → [22.184404:184502]

            return Err((crate::Error::CouldNotInferRepositoryName { repo: self.remote }).into());

[22.184404]

[22.184502]

            bail!("Could not infer repository name from {:?}", self.remote)

Insertion in pijul/src/commands/channel.rs at line 6 [22.186892]
[11.20]
[32.147]
```
use anyhow::bail;
```

Replacement in pijul/src/commands/channel.rs at line 42 [22.186892]

B:BD[22.187789] → [22.187789:187844]

                for channel in txn.iter_channels("") {

[22.187789]

[22.187844]

                for channel in txn.iter_channels("")? {
                    let channel = channel?;

Replacement in pijul/src/commands/channel.rs at line 57 [22.186892]

B:BD[34.1311] → [26.6297:6378]

                    return Err(crate::Error::CannotDeleteCurrentChannel.into());

[34.1311]

[34.1391]

                    bail!("Cannot delete current channel")

Replacement in pijul/src/commands/channel.rs at line 83 [22.186892]

B:BD[22.188748] → [22.188748:188819]

                    return Err(crate::Error::NoCurrentChannel.into());

[22.188748]

[22.188819]

                    bail!("No current channel")

Replacement in pijul/src/commands/channel.rs at line 85 [22.186892]

B:BD[22.188838] → [22.188838:188920]

                let mut channel = if let Some(channel) = txn.load_channel(from) {

[22.188838]

[22.188920]

                let mut channel = if let Some(channel) = txn.load_channel(from)? {

Replacement in pijul/src/commands/channel.rs at line 88 [22.186892]

B:BD[22.188973] → [22.188973:189141]

                    return Err((crate::Error::ChannelNotFound {
                        channel: from.to_string(),
                    })
                    .into());

[22.188973]

[22.189141]

                    bail!("No such channel: {:?}", from)

Replacement in pijul/src/commands/change.rs at line 30 [22.189306]

B:BD[12.70] → [12.70:152]

            let channel = if let Some(channel) = txn.load_channel(channel_name) {

[12.70]

[12.152]

            let channel = if let Some(channel) = txn.load_channel(channel_name)? {

Replacement in pijul/src/commands/change.rs at line 36 [22.189306]

B:BD[12.287] → [12.287:385]

            if let Some((_, (h, _))) = txn.reverse_log(&channel, None).next() {
                h

[12.287]

[12.385]

            if let Some(h) = txn.reverse_log(&channel, None)?.next() {
                (h?.1).0

Replacement in pijul/src/commands/archive.rs at line 90 [22.191083]

B:BD[22.193497] → [22.193497:193573]

                let mut channel = txn.load_channel(&channel_name).unwrap();

[22.193497]

[22.193573]

                let mut channel = txn.load_channel(&channel_name)?.unwrap();

Replacement in pijul/src/commands/archive.rs at line 100 [22.191083]

B:BD[22.193869] → [22.193869:193941]

                let channel = txn.load_channel(&channel_name).unwrap();

[22.193869]

[22.193941]

                let channel = txn.load_channel(&channel_name)?.unwrap();

Replacement in pijul/src/commands/apply.rs at line 31 [22.194289]

B:BD[22.195050] → [22.195050:195133]

        let mut channel = if let Some(channel) = txn.load_channel(&channel_name) {

[22.195050]

[22.195133]

        let mut channel = if let Some(channel) = txn.load_channel(&channel_name)? {

Replacement in pijul/Cargo.toml at line 4 [22.196374]
B:BD[22.196462] → [19.51:78]
```
version = "1.0.0-alpha.26"
```
[22.196462]
[22.196488]
```
version = "1.0.0-alpha.27"
```

Replacement in pijul/Cargo.toml at line 49 [22.196374]

B:BD[22.197438] → [22.197438:197456]

B:BD[22.197456] → [19.79:147]

thiserror = "1.0"
libpijul = { version = "1.0.0-alpha.22", features = [ "tarball" ] }

[22.197438]

[22.197523]

libpijul = { version = "1.0.0-alpha.23", features = [ "tarball" ] }

Replacement in pijul/Cargo.toml at line 64 [22.196374]
B:BD[22.197874] → [45.0:21]
```
sanakirja = "0.14.2"
```
[22.197874]
[22.197895]
```
sanakirja = "0.15.2"
```
Replacement in libpijul/src/working_copy/filesystem.rs at line 107 [22.208900]
∅:D[46.398] → [23.3775:3824]
B:BD[22.210434] → [23.3775:3824]
```
    ) -> Result<(), Error<C::Error, T::Error>> {
```
[46.398]
[22.210471]
```
    ) -> Result<(), Error<C::Error, T::GraphError>> {
```
Replacement in libpijul/src/working_copy/filesystem.rs at line 140 [22.208900]
∅:D[46.875] → [23.3825:3867]
B:BD[40.1792] → [23.3825:3867]
```
    ) -> Result<(), AddError<T::Error>> {
```
[46.875]
[40.1829]
```
    ) -> Result<(), AddError<T::GraphError>> {
```

Replacement in libpijul/src/working_copy/filesystem.rs at line 149 [22.208900]

∅:D[38.1902] → [46.984:1063]

B:BD[46.984] → [46.984:1063]

        let t = std::thread::spawn(move || -> Result<(), AddError<T::Error>> {

[38.1902]

[46.1063]

        let t = std::thread::spawn(move || -> Result<(), AddError<T::GraphError>> {

Replacement in libpijul/src/working_copy/filesystem.rs at line 219 [22.208900]
∅:D[46.3130] → [23.3868:3917]
B:BD[22.211282] → [23.3868:3917]
```
    ) -> Result<(), Error<C::Error, T::Error>> {
```
[46.3130]
[38.2643]
```
    ) -> Result<(), Error<C::Error, T::GraphError>> {
```
Replacement in libpijul/src/unrecord/working_copy.rs at line 6 [22.225940]
∅:D[47.1] → [22.226152:226191]
B:BD[22.226152] → [22.226152:226191]
```
pub fn undo_file_addition<T: MutTxnT>(
```
[47.1]
[22.226191]
```
pub fn undo_file_addition<
    T: GraphMutTxnT + TreeMutTxnT<TreeError = <T as GraphTxnT>::GraphError>,
>(
```
Replacement in libpijul/src/unrecord/working_copy.rs at line 12 [22.225940]
B:BD[22.226275] → [23.6687:6715]
```
) -> Result<(), T::Error> {
```
[22.226275]
[22.226308]
```
) -> Result<(), TxnErr<T::GraphError>> {
```

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

B:BD[22.226458] → [22.226458:226518]

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

[22.226458]

[41.353]

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

Replacement in libpijul/src/unrecord/working_copy.rs at line 25 [22.225940]

∅:D[47.3] → [22.226729:226784]

B:BD[22.226729] → [22.226729:226784]

pub fn undo_file_deletion<T: MutTxnT, P: ChangeStore>(

[47.3]

[22.226784]

pub fn undo_file_deletion<
    T: ChannelTxnT + TreeMutTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
    P: ChangeStore,
>(

Replacement in libpijul/src/unrecord/working_copy.rs at line 34 [22.225940]
B:BD[22.226907] → [23.6716:6776]
```
) -> Result<(), super::UnrecordError<P::Error, T::Error>> {
```
[22.226907]
[22.226940]
```
) -> Result<(), super::UnrecordError<P::Error, T::TreeError>> {
```

Replacement in libpijul/src/unrecord/working_copy.rs at line 37 [22.225940]

B:BD[22.227037] → [26.6529:6622]

        let source = find_block_end(txn, &channel, internal_pos(txn, &e.from, change_id)?)?;

[22.227037]

[22.227128]

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

Replacement in libpijul/src/unrecord/working_copy.rs at line 46 [22.225940]

∅:D[47.5] → [22.227428:227468]

B:BD[22.227428] → [22.227428:227468]

fn restore<T: MutTxnT, P: ChangeStore>(

[47.5]

[22.227468]

fn restore<
    T: ChannelTxnT + TreeMutTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
    P: ChangeStore,
>(

Replacement in libpijul/src/unrecord/working_copy.rs at line 55 [22.225940]
B:BD[22.227588] → [23.6777:6837]
```
) -> Result<(), super::UnrecordError<P::Error, T::Error>> {
```
[22.227588]
[22.227621]
```
) -> Result<(), super::UnrecordError<P::Error, T::TreeError>> {
```

Replacement in libpijul/src/unrecord/working_copy.rs at line 63 [22.225940]

B:BD[22.227921] → [26.6697:6740]

        let source_parent = iter_adjacent(

[22.227921]

[26.6740]

        let mut source_parent = None;
        for e in iter_adjacent(

Replacement in libpijul/src/unrecord/working_copy.rs at line 66 [22.225940]
B:BD[26.6757] → [26.6757:6779]
```
            &channel,
```
[26.6757]
[26.6779]
```
            &channel.graph,
```

Replacement in libpijul/src/unrecord/working_copy.rs at line 70 [22.225940]

B:BD[26.6880] → [26.6880:6890]

B:BD[26.6890] → [39.1769:1843]

∅:D[39.1843] → [26.6982:7015]

B:BD[26.6982] → [26.6982:7015]

        )
        .find(|e| e.flag.contains(EdgeFlags::PARENT | EdgeFlags::FOLDER))
        .unwrap()
        .dest;

[26.6880]

[47.6]

        )? {
            let e = e?;
            if e.flag.contains(EdgeFlags::PARENT | EdgeFlags::FOLDER) {
                source_parent = Some(e.dest);
                break;
            }
        }
        let source_parent = source_parent.unwrap();

Replacement in libpijul/src/unrecord/working_copy.rs at line 81 [22.225940]

∅:D[23.6928] → [22.228471:228548]

B:BD[22.228471] → [22.228471:228548]

        } 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 92 [22.225940]

∅:D[47.9] → [22.228923:228969]

B:BD[22.228923] → [22.228923:228969]

fn restore_inode<T: MutTxnT, P: ChangeStore>(

[47.9]

[22.228969]

fn restore_inode<
    T: TreeMutTxnT + GraphTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
    P: ChangeStore,
>(

Replacement in libpijul/src/unrecord/working_copy.rs at line 101 [22.225940]
B:BD[22.229088] → [23.7014:7077]
```
) -> Result<Inode, super::UnrecordError<P::Error, T::Error>> {
```
[22.229088]
[22.229174]
```
) -> Result<Inode, super::UnrecordError<P::Error, T::TreeError>> {
```

Replacement in libpijul/src/unrecord/working_copy.rs at line 104 [22.225940]

B:BD[23.7110] → [23.7110:7177]

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

[23.7110]

[23.7177]

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

Replacement in libpijul/src/unrecord/working_copy.rs at line 111 [22.225940]
B:BD[22.229428] → [47.10:67]
```
    if let Some(inode) = txn.get_revinodes(dest, None) {
```
[22.229428]
[47.67]
```
    if let Some(inode) = txn.get_revinodes(dest, None)? {
```

Replacement in libpijul/src/unrecord/working_copy.rs at line 114 [22.225940]

B:BD[47.98] → [47.98:152]

B:BD[47.152] → [23.7232:7412]

        let inode = crate::fs::create_new_inode(txn);
        put_tree_with_rev(txn, file_id.as_file_id(), inode).map_err(super::UnrecordError::Txn)?;
        put_inodes_with_rev(txn, inode, dest).map_err(super::UnrecordError::Txn)?;

[47.98]

[47.338]

        let inode = crate::fs::create_new_inode(txn)?;
        put_tree_with_rev(txn, file_id.as_file_id(), inode)?;
        put_inodes_with_rev(txn, inode, dest)?;

Replacement in libpijul/src/unrecord/working_copy.rs at line 121 [22.225940]
∅:D[47.364] → [22.229677:229711]
B:BD[22.229677] → [22.229677:229711]
```
fn find_youngest_parent<T: TxnT>(
```
[47.364]
[22.229711]
```
fn find_youngest_parent<T: ChannelTxnT>(
```
Replacement in libpijul/src/unrecord/working_copy.rs at line 125 [22.225940]
B:BD[22.229781] → [23.7413:7457]
```
) -> Result<Vertex<ChangeId>, BlockError> {
```
[22.229781]
[22.229827]
```
) -> Result<Vertex<ChangeId>, BlockError<T::GraphError>> {
```
Replacement in libpijul/src/unrecord/working_copy.rs at line 129 [22.225940]
B:BD[26.7057] → [26.7057:7074]
```
        channel,
```
[26.7057]
[26.7074]
```
        &channel.graph,
```

Replacement in libpijul/src/unrecord/working_copy.rs at line 133 [22.225940]

B:BD[26.7225] → [26.7225:7303]

∅:D[26.7303] → [22.230163:230169]

B:BD[22.230163] → [22.230163:230169]

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

[26.7225]

[22.230169]

    )? {
        let e = e?;
        if !e.flag.contains(EdgeFlags::FOLDER | EdgeFlags::PARENT) {
            continue;
        }

Replacement in libpijul/src/unrecord/working_copy.rs at line 141 [22.225940]

B:BD[22.230244] → [22.230244:230316]

                .get_changeset(&channel.changes, e.introduced_by, None)

[22.230244]

[22.230316]

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

Replacement in libpijul/src/unrecord/working_copy.rs at line 156 [22.225940]
B:BD[22.230687] → [26.7304:7354]
```
    find_block_end(txn, channel, next.unwrap().1)
```
[22.230687]
[22.230736]
```
    find_block_end(txn, &channel.graph, next.unwrap().1)
```

Replacement in libpijul/src/unrecord/working_copy.rs at line 159 [22.225940]

B:BD[22.230739] → [23.7458:7516]

pub fn undo_file_reinsertion<P: ChangeStore, T: MutTxnT>(

[22.230739]

[22.230836]

pub fn undo_file_reinsertion<
    P: ChangeStore,
    T: GraphTxnT + TreeMutTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
>(

Replacement in libpijul/src/unrecord/working_copy.rs at line 166 [22.225940]
B:BD[22.230916] → [23.7517:7577]
```
) -> Result<(), super::UnrecordError<P::Error, T::Error>> {
```
[22.230916]
[22.230949]
```
) -> Result<(), super::UnrecordError<P::Error, T::TreeError>> {
```

Replacement in libpijul/src/unrecord/working_copy.rs at line 171 [22.225940]

∅:D[26.7432] → [22.231227:231296]

B:BD[22.231227] → [22.231227:231296]

B:BD[22.231296] → [23.7578:7673]

            if let Some(inode) = txn.get_revinodes(position, None) {
                del_inodes_with_rev(txn, inode, position).map_err(super::UnrecordError::Txn)?;

[26.7432]

[22.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 21 [22.231493]
B:BD[23.7965] → [23.7965:8013]
```
    Block(#[from] crate::pristine::BlockError),
```
[23.7965]
[23.8013]
```
    Block(#[from] crate::pristine::BlockError<TxnError>),
```

Replacement in libpijul/src/unrecord/mod.rs at line 23 [22.231493]

B:BD[23.8039] → [23.8039:8108]

    InconsistentChange(#[from] crate::pristine::InconsistentChange),

[23.8039]

[23.8108]

    InconsistentChange(#[from] crate::pristine::InconsistentChange<TxnError>),

Insertion in libpijul/src/unrecord/mod.rs at line 34 [22.231493]

[23.8611]

}
impl<T: std::error::Error + 'static, C: std::error::Error + 'static> std::convert::From<TxnErr<T>>
    for UnrecordError<C, T>
{
    fn from(t: TxnErr<T>) -> Self {
        UnrecordError::Txn(t.0)
    }

Replacement in libpijul/src/unrecord/mod.rs at line 49 [22.231493]
B:BD[22.231881] → [23.8615:8670]
```
) -> Result<bool, UnrecordError<P::Error, T::Error>> {
```
[22.231881]
[23.8670]
```
) -> Result<bool, UnrecordError<P::Error, T::GraphError>> {
```
Replacement in libpijul/src/unrecord/mod.rs at line 53 [22.231493]
∅:D[23.8768] → [22.231960:232023]
B:BD[22.231960] → [22.231960:232023]
```
    let change_id = if let Some(h) = txn.get_internal(*hash) {
```
[23.8768]
[22.232023]
```
    let change_id = if let Some(h) = txn.get_internal(*hash)? {
```

Replacement in libpijul/src/unrecord/mod.rs at line 58 [22.231493]

B:BD[22.232079] → [22.232079:232148]

    let unused = unused_in_other_channels(txn, &channel, change_id);

[22.232079]

[22.232148]

    let unused = unused_in_other_channels(txn, &channel, change_id)?;

Replacement in libpijul/src/unrecord/mod.rs at line 66 [22.231493]

B:BD[22.232331] → [22.232331:232391]

B:BD[22.232391] → [23.8834:9062]

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

[22.232331]

[22.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, None)?;

Replacement in libpijul/src/unrecord/mod.rs at line 71 [22.231493]

B:BD[22.232570] → [22.232570:232625]

B:BD[22.232625] → [23.9063:9159]

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

[22.232570]

[22.232676]

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

Replacement in libpijul/src/unrecord/mod.rs at line 80 [22.231493]

B:BD[23.9161] → [23.9161:9213]

fn del_channel_changes<T: MutTxnT, P: ChangeStore>(

[23.9161]

[22.232833]

fn del_channel_changes<
    T: ChannelMutTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
    P: ChangeStore,
>(

Replacement in libpijul/src/unrecord/mod.rs at line 87 [22.231493]

B:BD[22.232905] → [23.9214:9267]

∅:D[23.9267] → [22.232938:233031]

B:BD[22.232938] → [22.232938:233031]

) -> Result<(), UnrecordError<P::Error, T::Error>> {
    let timestamp = if let Some(ts) = txn.get_changeset(&channel.changes, change_id, None) {

[22.232905]

[22.233031]

) -> Result<(), UnrecordError<P::Error, T::GraphError>> {
    let timestamp = if let Some(ts) = txn.get_changeset(&channel.changes, change_id, None)? {

Replacement in libpijul/src/unrecord/mod.rs at line 94 [22.231493]

B:BD[22.233133] → [22.233133:233180]

    for (p, d) in txn.iter_revdep(change_id) {

[22.233133]

[22.233180]

    for x in txn.iter_revdep(change_id)? {
        let (p, d) = x?;

Replacement in libpijul/src/unrecord/mod.rs at line 101 [22.231493]

B:BD[22.233292] → [22.233292:233360]

        if txn.get_changeset(&channel.changes, d, None).is_some() {

[22.233292]

[23.9344]

        if txn.get_changeset(&channel.changes, d, None)?.is_some() {

Replacement in libpijul/src/unrecord/mod.rs at line 106 [22.231493]

B:BD[22.233453] → [23.9420:9510]

    txn.del_changes(channel, change_id, timestamp)
        .map_err(UnrecordError::Txn)?;

[22.233453]

[22.233506]

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

Replacement in libpijul/src/unrecord/mod.rs at line 114 [22.231493]
B:BD[22.233683] → [22.233683:233695]
```
) -> bool {
```
[22.233683]
[22.233695]
```
) -> Result<bool, TxnErr<T::GraphError>> {
```
Replacement in libpijul/src/unrecord/mod.rs at line 116 [22.231493]
B:BD[22.233731] → [22.233731:233769]
```
    for br in txn.iter_channels("") {
```
[22.233731]
[22.233769]
```
    for br in txn.iter_channels("")? {
        let br = br?;
```

Replacement in libpijul/src/unrecord/mod.rs at line 119 [22.231493]

B:BD[22.233799] → [39.1844:1968]

        if br.name != channel.name && txn.get_changeset(&br.changes, change_id, None).is_some() {
            return false;

[22.233799]

[22.233955]

        if br.name != channel.name && txn.get_changeset(&br.changes, change_id, None)?.is_some() {
            return Ok(false);

Replacement in libpijul/src/unrecord/mod.rs at line 123 [22.231493]
B:BD[22.233971] → [22.233971:233980]
```
    true
```
[22.233971]
[22.233980]
```
    Ok(true)
```
Replacement in libpijul/src/unrecord/mod.rs at line 126 [22.231493]
∅:D[23.9514] → [22.234037:234077]
B:BD[22.234037] → [22.234037:234077]
```
fn unapply<T: MutTxnT, C: ChangeStore>(
```
[23.9514]
[22.234077]
```
fn unapply<
    T: ChannelMutTxnT + TreeMutTxnT<TreeError = <T as GraphTxnT>::GraphError>,
    C: ChangeStore,
>(
```
Replacement in libpijul/src/unrecord/mod.rs at line 135 [22.231493]
B:BD[22.234187] → [23.9515:9568]
```
) -> Result<(), UnrecordError<C::Error, T::Error>> {
```
[22.234187]
[22.234220]
```
) -> Result<(), UnrecordError<C::Error, T::GraphError>> {
```

Replacement in libpijul/src/unrecord/mod.rs at line 140 [22.231493]

B:BD[22.234399] → [22.234399:234542]

            Atom::EdgeMap(ref newedges) => {
                unapply_edges(changes, txn, channel, change_id, newedges, &mut ws)?
            }

[22.234399]

[22.234542]

            Atom::EdgeMap(ref newedges) => unapply_edges(
                changes,
                txn,
                &mut channel.graph,
                change_id,
                newedges,
                &mut ws,
            )?,

Replacement in libpijul/src/unrecord/mod.rs at line 152 [22.231493]
B:BD[22.234733] → [22.234733:234766]
```
                        channel,
```
[22.234733]
[26.7433]
```
                        &mut channel.graph,
```

Replacement in libpijul/src/unrecord/mod.rs at line 154 [22.231493]

B:BD[26.7506] → [23.9569:9642]

                    )
                    .map_err(UnrecordError::Txn)?;

[26.7506]

[22.234862]

)?

Replacement in libpijul/src/unrecord/mod.rs at line 156 [22.231493]

B:BD[22.234880] → [23.9643:9731]

                unapply_newvertex::<T, C>(txn, channel, change_id, &mut ws, newvertex)?

[22.234880]

[22.234960]

                unapply_newvertex::<T, C>(txn, &mut channel.graph, change_id, &mut ws, newvertex)?

Replacement in libpijul/src/unrecord/mod.rs at line 160 [22.231493]

B:BD[22.234990] → [21.40:114]

    repair_newvertex_contexts::<T, C>(txn, channel, &mut ws, change_id)?;

[22.234990]

[22.235104]

    repair_newvertex_contexts::<T, C>(txn, &mut channel.graph, &mut ws, change_id)?;

Replacement in libpijul/src/unrecord/mod.rs at line 163 [22.231493]

B:BD[39.2017] → [21.115:189]

            remove_zombies::<_, C>(txn, channel, &mut ws, change_id, n)?;

[39.2017]

[39.2074]

            remove_zombies::<_, C>(txn, &mut channel.graph, &mut ws, change_id, n)?;

Replacement in libpijul/src/unrecord/mod.rs at line 167 [22.231493]
B:BD[39.2154] → [39.2154:2179]
```
                channel,
```
[39.2154]
[39.2179]
```
                &mut channel.graph,
```

Replacement in libpijul/src/unrecord/mod.rs at line 188 [22.231493]

B:BD[48.958] → [48.958:1086]

                working_copy::undo_file_addition(txn, change_id, new_vertex)
                    .map_err(UnrecordError::Txn)?;

[48.958]

[48.1086]

                working_copy::undo_file_addition(txn, change_id, new_vertex)?;

Replacement in libpijul/src/unrecord/mod.rs at line 194 [22.231493]

B:BD[48.1137] → [21.190:347]

    crate::apply::clean_obsolete_pseudo_edges(txn, channel, &mut ws.apply, change_id)?;
    crate::apply::repair_cyclic_paths(txn, channel, &mut ws.apply)?;

[48.1137]

[22.235674]

    crate::apply::clean_obsolete_pseudo_edges(txn, &mut channel.graph, &mut ws.apply, change_id)?;
    crate::apply::repair_cyclic_paths(txn, &mut channel.graph, &mut ws.apply)?;

Replacement in libpijul/src/unrecord/mod.rs at line 211 [22.231493]
B:BD[22.236205] → [23.9862:9912]
```
fn unapply_newvertex<T: MutTxnT, C: ChangeStore>(
```
[22.235980]
[22.236239]
```
fn unapply_newvertex<T: GraphMutTxnT, C: ChangeStore>(
```
Replacement in libpijul/src/unrecord/mod.rs at line 213 [22.231493]
B:BD[22.236256] → [22.236256:236286]
```
    channel: &mut Channel<T>,
```
[22.236256]
[22.236286]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/unrecord/mod.rs at line 217 [22.231493]
B:BD[22.236377] → [23.9913:9966]
```
) -> Result<(), UnrecordError<C::Error, T::Error>> {
```
[22.236377]
[22.236410]
```
) -> Result<(), UnrecordError<C::Error, T::GraphError>> {
```

Replacement in libpijul/src/unrecord/mod.rs at line 225 [22.231493]

B:BD[22.237225] → [21.611:665]

        for e in iter_adj_all(txn, channel, vertex) {

[22.237225]

[22.237317]

        for e in iter_adj_all(txn, channel, vertex)? {
            let e = e?;

Replacement in libpijul/src/unrecord/mod.rs at line 256 [22.231493]
B:BD[21.1166] → [21.1166:1214]
```
    fn perform_del<C: ChangeStore, T: MutTxnT>(
```
[21.1166]
[21.1214]
```
    fn perform_del<C: ChangeStore, T: GraphMutTxnT>(
```
Replacement in libpijul/src/unrecord/mod.rs at line 259 [22.231493]
B:BD[21.1254] → [21.1254:1288]
```
        channel: &mut Channel<T>,
```
[21.1254]
[21.1288]
```
        channel: &mut T::Graph,
```

Replacement in libpijul/src/unrecord/mod.rs at line 261 [22.231493]

B:BD[21.1322] → [21.1322:1379]

    ) -> Result<(), UnrecordError<C::Error, T::Error>> {

[21.1322]

[21.1379]

    ) -> Result<(), UnrecordError<C::Error, T::GraphError>> {

Replacement in libpijul/src/unrecord/mod.rs at line 275 [22.231493]
B:BD[26.8203] → [23.9967:10024]
```
            )
            .map_err(UnrecordError::Txn)?;
```
[26.8203]
[22.238504]
```
            )?;
```
Replacement in libpijul/src/unrecord/mod.rs at line 281 [22.231493]
B:BD[22.238934] → [23.10125:10183]
```
fn repair_newvertex_contexts<T: MutTxnT, C: ChangeStore>(
```
[22.238934]
[22.238976]
```
fn repair_newvertex_contexts<T: GraphMutTxnT, C: ChangeStore>(
```
Replacement in libpijul/src/unrecord/mod.rs at line 283 [22.231493]
B:BD[22.238993] → [22.238993:239023]
```
    channel: &mut Channel<T>,
```
[22.238993]
[22.239023]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/unrecord/mod.rs at line 286 [22.231493]
∅:D[21.1508] → [23.10184:10237]
B:BD[22.239047] → [23.10184:10237]
```
) -> Result<(), UnrecordError<C::Error, T::Error>> {
```
[21.1508]
[22.239080]
```
) -> Result<(), UnrecordError<C::Error, T::GraphError>> {
```
Replacement in libpijul/src/unrecord/mod.rs at line 289 [22.231493]
B:BD[22.239152] → [26.8220:8260]
```
        if is_alive(txn, channel, up) {
```
[22.239152]
[22.239191]
```
        if is_alive(txn, channel, up)? {
```
Replacement in libpijul/src/unrecord/mod.rs at line 309 [22.231493]
B:BD[22.239740] → [22.239740:239752]
```
        ) {
```
[22.239740]
[26.8316]
```
        )? {
            let parent = parent?;
```

Replacement in libpijul/src/unrecord/mod.rs at line 312 [22.231493]

B:BD[26.8385] → [26.8385:8434]

            if !is_alive(txn, channel, parent) {

[26.8385]

[21.1553]

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

Replacement in libpijul/src/unrecord/mod.rs at line 332 [22.231493]
∅:D[23.10239] → [22.240360:240406]
B:BD[22.240360] → [22.240360:240406]
```
fn unapply_edges<T: MutTxnT, P: ChangeStore>(
```
[23.10239]
[22.240406]
```
fn unapply_edges<T: GraphMutTxnT, P: ChangeStore>(
```
Replacement in libpijul/src/unrecord/mod.rs at line 335 [22.231493]
B:BD[22.240440] → [22.240440:240470]
```
    channel: &mut Channel<T>,
```
[22.240440]
[22.240470]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/unrecord/mod.rs at line 339 [22.231493]
B:BD[22.240557] → [23.10240:10293]
```
) -> Result<(), UnrecordError<P::Error, T::Error>> {
```
[22.240557]
[22.240590]
```
) -> Result<(), UnrecordError<P::Error, T::GraphError>> {
```
Replacement in libpijul/src/unrecord/mod.rs at line 341 [22.231493]
B:BD[22.240632] → [22.240632:240684]
```
    let ext = txn.get_external(change_id).unwrap();
```
[22.240632]
[22.240757]
```
    let ext = txn.get_external(change_id)?.unwrap();
```

Replacement in libpijul/src/unrecord/mod.rs at line 343 [22.231493]

B:BD[22.240797] → [21.1710:1786]

        let intro = internal(txn, &edge.introduced_by, change_id).unwrap();

[22.240797]

[22.240940]

        let intro = internal(txn, &edge.introduced_by, change_id)?.unwrap();

Replacement in libpijul/src/unrecord/mod.rs at line 359 [22.231493]
B:BD[22.241975] → [22.241975:242021]
```
fn must_reintroduce<T: TxnT, C: ChangeStore>(
```
[22.241975]
[22.242021]
```
fn must_reintroduce<T: GraphTxnT, C: ChangeStore>(
```
Replacement in libpijul/src/unrecord/mod.rs at line 361 [22.231493]
B:BD[22.242034] → [22.242034:242060]
```
    channel: &Channel<T>,
```
[22.242034]
[22.242060]
```
    channel: &T::Graph,
```
Replacement in libpijul/src/unrecord/mod.rs at line 368 [22.231493]
∅:D[21.1958] → [23.10378:10444]
B:BD[22.242168] → [23.10378:10444]
```
) -> Result<bool, crate::apply::ApplyError<C::Error, T::Error>> {
```
[21.1958]
[22.242203]
```
) -> Result<bool, UnrecordError<C::Error, T::GraphError>> {
```
Replacement in libpijul/src/unrecord/mod.rs at line 373 [22.231493]
B:BD[22.242373] → [22.242373:242417]
```
        change: txn.get_external(b.change),
```
[22.242373]
[22.242417]
```
        change: txn.get_external(b.change)?,
```

Replacement in libpijul/src/unrecord/mod.rs at line 377 [22.231493]

B:BD[22.242478] → [21.1959:2185]

∅:D[21.2185] → [26.8706:8715]

B:BD[26.8706] → [26.8706:8715]

    for e in iter_adj_all(txn, channel, a).filter(|e| {
        !e.flag.contains(EdgeFlags::PARENT)
            && e.dest == b.start_pos()
            && !e.introduced_by.is_root()
            && e.introduced_by != current_id
    }) {

[22.242478]

[21.2186]

    for e in iter_adj_all(txn, channel, a)? {
        let e = e?;
        if e.flag.contains(EdgeFlags::PARENT)
            || e.dest != b.start_pos()
            || e.introduced_by.is_root()
            || e.introduced_by == current_id
        {
            continue;
        }

Deletion in libpijul/src/unrecord/mod.rs at line 396 [22.231493]
B:BD[22.243261] → [23.10445:10501]
```
        .map_err(crate::apply::ApplyError::Changestore)
```
Replacement in libpijul/src/unrecord/mod.rs at line 398 [22.231493]
B:BD[22.243264] → [22.243264:243312]
```
fn edge_is_in_channel<T: TxnT, C: ChangeStore>(
```
[22.243264]
[22.243312]
```
fn edge_is_in_channel<T: GraphTxnT, C: ChangeStore>(
```
Replacement in libpijul/src/unrecord/mod.rs at line 404 [22.231493]
B:BD[22.243431] → [23.10502:10532]
```
) -> Result<bool, C::Error> {
```
[22.243431]
[22.243466]
```
) -> Result<bool, UnrecordError<C::Error, T::GraphError>> {
```

Replacement in libpijul/src/unrecord/mod.rs at line 411 [22.231493]

B:BD[22.243640] → [22.243640:243728]

        for next in changes.change_deletes_position(|c| txn.get_external(c), s, pos)? {

[22.243640]

[22.243728]

        for next in changes
            .change_deletes_position(|c| txn.get_external(c).unwrap(), s, pos)
            .map_err(UnrecordError::Changestore)?
        {

Replacement in libpijul/src/unrecord/mod.rs at line 417 [22.231493]

B:BD[22.243801] → [22.243801:243862]

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

[22.243801]

[22.243862]

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

Replacement in libpijul/src/unrecord/mod.rs at line 425 [22.231493]
B:BD[22.243938] → [23.10533:10580]
```
fn remove_zombies<T: MutTxnT, C: ChangeStore>(
```
[22.243938]
[22.243969]
```
fn remove_zombies<T: GraphMutTxnT, C: ChangeStore>(
```
Replacement in libpijul/src/unrecord/mod.rs at line 427 [22.231493]
B:BD[22.243986] → [22.243986:244016]
```
    channel: &mut Channel<T>,
```
[22.243986]
[21.2508]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/unrecord/mod.rs at line 431 [22.231493]
B:BD[22.244079] → [23.10581:10634]
```
) -> Result<(), UnrecordError<C::Error, T::Error>> {
```
[22.244079]
[22.244208]
```
) -> Result<(), UnrecordError<C::Error, T::GraphError>> {
```

Replacement in libpijul/src/unrecord/mod.rs at line 441 [22.231493]

B:BD[21.2745] → [21.2745:2876]

                del_graph_with_rev(txn, channel, e.flag, u, v, e.introduced_by)
                    .map_err(UnrecordError::Txn)?;

[21.2745]

[22.246602]

                del_graph_with_rev(txn, channel, e.flag, u, v, e.introduced_by)?;

Replacement in libpijul/src/unrecord/mod.rs at line 444 [22.231493]

B:BD[26.9860] → [23.10829:10960]

                del_graph_with_rev(txn, channel, e.flag, v, w, e.introduced_by)
                    .map_err(UnrecordError::Txn)?;

[26.9860]

[22.246762]

                del_graph_with_rev(txn, channel, e.flag, v, w, e.introduced_by)?;

Replacement in libpijul/src/unrecord/mod.rs at line 451 [22.231493]

B:BD[22.246806] → [21.2877:2953]

fn collect_zombies<T: TxnT>(
    txn: &mut T,
    channel: &mut Channel<T>,

[22.246806]

[21.2953]

fn collect_zombies<T: GraphTxnT>(
    txn: &T,
    channel: &T::Graph,

Replacement in libpijul/src/unrecord/mod.rs at line 457 [22.231493]
B:BD[21.3030] → [21.3030:3060]
```
) -> Result<(), BlockError> {
```
[21.3030]
[21.3060]
```
) -> Result<(), BlockError<T::GraphError>> {
```

Replacement in libpijul/src/unrecord/mod.rs at line 464 [22.231493]

B:BD[21.3265] → [21.3265:3314]

        for e in iter_adj_all(txn, channel, v) {

[21.3265]

[21.3314]

        for e in iter_adj_all(txn, channel, v)? {
            let e = e?;

Replacement in libpijul/src/unrecord/mod.rs at line 485 [22.231493]
∅:D[21.3886] → [22.246861:246914]
B:BD[22.246861] → [22.246861:246914]
```
fn repair_edges_context<T: MutTxnT, P: ChangeStore>(
```
[21.3886]
[22.246914]
```
fn repair_edges_context<T: GraphMutTxnT, P: ChangeStore>(
```
Replacement in libpijul/src/unrecord/mod.rs at line 488 [22.231493]
B:BD[22.246948] → [22.246948:246978]
```
    channel: &mut Channel<T>,
```
[22.246948]
[22.246978]
```
    channel: &mut T::Graph,
```

Replacement in libpijul/src/unrecord/mod.rs at line 492 [22.231493]

B:BD[22.247082] → [23.10961:11014]

∅:D[23.11014] → [22.247115:247175]

B:BD[22.247115] → [22.247115:247175]

) -> Result<(), UnrecordError<P::Error, T::Error>> {
    let change_hash = txn.get_external(change_id).unwrap();

[22.247082]

[22.247175]

) -> Result<(), UnrecordError<P::Error, T::GraphError>> {
    let change_hash = txn.get_external(change_id)?.unwrap();

Replacement in libpijul/src/unrecord/mod.rs at line 496 [22.231493]

B:BD[22.247259] → [21.3887:3960]

        let intro = internal(txn, &e.introduced_by, change_id).unwrap();

[22.247259]

[21.3960]

        let intro = internal(txn, &e.introduced_by, change_id)?.unwrap();

Replacement in libpijul/src/unrecord/mod.rs at line 511 [22.231493]
B:BD[26.10222] → [26.10222:10267]
```
            if !is_alive(txn, channel, to) {
```
[26.10222]
[22.248246]
```
            if !is_alive(txn, channel, to)? {
```
Replacement in libpijul/src/tests/unrecord.rs at line 128 [22.248807]
B:BD[22.252619] → [22.252619:252654]
```
            .map(|(_, name)| name)
```
[22.252619]
[22.252654]
```
            .map(|n| n.unwrap().1)
```
Replacement in libpijul/src/tests/unrecord.rs at line 137 [22.248807]
B:BD[22.252958] → [22.252958:252993]
```
            .map(|(_, name)| name)
```
[22.252958]
[22.252993]
```
            .map(|n| n.unwrap().1)
```

Replacement in libpijul/src/tests/unrecord.rs at line 314 [22.248807]

B:BD[22.258535] → [26.10861:10921]

    let (alive_, reachable_) = check_alive(&txn, &channel);

[22.258535]

[22.258593]

    let (alive_, reachable_) = check_alive(&txn, &channel.borrow().graph);

Replacement in libpijul/src/tests/unrecord.rs at line 399 [22.248807]

B:BD[22.261132] → [26.11125:11185]

    let (alive_, reachable_) = check_alive(&txn, &channel);

[22.261132]

[22.261190]

    let (alive_, reachable_) = check_alive(&txn, &channel.borrow().graph);

Replacement in libpijul/src/tests/unrecord.rs at line 449 [22.248807]
B:BD[22.262885] → [22.262885:262930]
```
    for p in txn.log(&channel.borrow(), 0) {
```
[22.262885]
[22.262930]
```
    for p in txn.log(&channel.borrow(), 0).unwrap() {
```
Replacement in libpijul/src/tests/unrecord.rs at line 457 [22.248807]
B:BD[22.263107] → [22.263107:263152]
```
    for p in txn.log(&channel.borrow(), 0) {
```
[22.263107]
[22.263152]
```
    for p in txn.log(&channel.borrow(), 0).unwrap() {
```
Replacement in libpijul/src/tests/unrecord.rs at line 938 [22.248807]
B:BD[47.1754] → [47.1754:1794]
```
    let mut inodes = txn.iter_inodes();
```
[47.1754]
[47.1794]
```
    let mut inodes = txn.iter_inodes().unwrap();
```

Replacement in libpijul/src/tests/performance.rs at line 53 [22.278146]

B:BD[22.279859] → [22.279859:279923]

        let m = txn.cursor_graph(&channel.graph, None).count();

[22.279859]

[22.279923]

        let m = txn.cursor_graph(&channel.graph, None).unwrap().count();

Replacement in libpijul/src/tests/performance.rs at line 136 [22.278146]

B:BD[22.282440] → [22.282440:282504]

        let m = txn.cursor_graph(&channel.graph, None).count();

[22.282440]

[22.282504]

        let m = txn.cursor_graph(&channel.graph, None).unwrap().count();

Replacement in libpijul/src/tests/performance.rs at line 145 [22.278146]

B:BD[22.282737] → [22.282737:282801]

        let m = txn.cursor_graph(&channel.graph, None).count();

[22.282737]

[22.282801]

        let m = txn.cursor_graph(&channel.graph, None).unwrap().count();

Replacement in libpijul/src/tests/partial.rs at line 35 [22.285224]

B:BD[22.286507] → [22.286507:286648]

        let key = txn.get_inodes(inode, None).unwrap();
        let changes: Vec<_> = txn.log_for_path(&channel.borrow(), key, 0).collect();

[22.286507]

[22.286648]

        let key = txn.get_inodes(inode, None).unwrap().unwrap();
        let changes: Vec<_> = txn
            .log_for_path(&channel.borrow(), key, 0)
            .unwrap()
            .map(|x| x.unwrap())
            .collect();

Replacement in libpijul/src/tests/mod.rs at line 32 [22.289338]

B:BD[22.289967] → [22.289967:290043]

    state.record(txn, Algorithm::default(), channel, repo, store, prefix)?;

[22.289967]

[22.290043]

    state.record(
        txn,
        Algorithm::default(),
        &mut channel.borrow_mut(),
        repo,
        store,
        prefix,
    )?;

Replacement in libpijul/src/tests/mod.rs at line 45 [22.289338]
B:BD[22.290134] → [22.290134:290173]
```
        .map(|rec| rec.globalize(txn))
```
[22.290134]
[22.290173]
```
        .map(|rec| rec.globalize(txn).unwrap())
```
Replacement in libpijul/src/tests/mod.rs at line 62 [22.289338]
B:BD[22.290724] → [22.290724:290731]
```
    );
```
[22.290724]
[22.290731]
```
    )
    .unwrap();
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 569 [22.305506]

B:BD[22.322581] → [22.322581:322772]

    for x in txn_alice.iter_tree(
        OwnedPathId {
            parent_inode: Inode::ROOT,
            basename: crate::small_string::SmallString::new(),
        },
        None,
    ) {

[22.322581]

[22.322772]

    for x in txn_alice
        .iter_tree(
            OwnedPathId {
                parent_inode: Inode::ROOT,
                basename: crate::small_string::SmallString::new(),
            },
            None,
        )
        .unwrap()
    {

Replacement in libpijul/src/tests/file_conflicts.rs at line 1499 [22.305506]

B:BD[22.352588] → [26.21701:21771]

    let (alive, reachable) = check_alive(&txn_alice, &channel_alice);

[22.352588]

[22.352656]

    let (alive, reachable) = check_alive(&txn_alice, &channel_alice.borrow().graph);

Replacement in libpijul/src/tests/conflict.rs at line 1124 [22.357372]
B:BD[22.393790] → [22.393790:393826]
```
                &mut channel_alice,
```
[22.393790]
[22.393826]
```
                &mut channel_alice.borrow_mut(),
```

Replacement in libpijul/src/tests/conflict.rs at line 2335 [22.357372]

B:BD[26.30412] → [26.30412:30476]

    let (alive_, reachable_) = check_alive(&txn, &channel_bob);

[26.30412]

[22.433556]

    let (alive_, reachable_) = check_alive(&txn, &channel_bob.borrow().graph);

Replacement in libpijul/src/tests/conflict.rs at line 2352 [22.357372]

B:BD[26.30539] → [26.30539:30601]

    let (alive, reachable) = check_alive(&txn, &channel_bob);

[26.30539]

[22.434046]

    let (alive, reachable) = check_alive(&txn, &channel_bob.borrow().graph);

Replacement in libpijul/src/tests/conflict.rs at line 2369 [22.357372]

B:BD[26.30671] → [26.30671:30737]

    let (alive, reachable) = check_alive(&txn, &channel_charlie);

[26.30671]

[22.434801]

    let (alive, reachable) = check_alive(&txn, &channel_charlie.borrow().graph);

Replacement in libpijul/src/tests/conflict.rs at line 2386 [22.357372]

B:BD[22.435224] → [26.30809:30875]

    let (alive, reachable) = check_alive(&txn, &channel_charlie);

[22.435224]

[22.435288]

    let (alive, reachable) = check_alive(&txn, &channel_charlie.borrow().graph);

Replacement in libpijul/src/tests/conflict.rs at line 2465 [22.357372]

B:BD[22.437747] → [26.31013:31083]

    let (alive, reachable) = check_alive(&txn_alice, &channel_alice);

[22.437747]

[22.437815]

    let (alive, reachable) = check_alive(&txn_alice, &channel_alice.borrow().graph);

Replacement in libpijul/src/tests/conflict.rs at line 2550 [22.357372]

B:BD[22.440414] → [22.440414:440461]

    for (inode, vertex) in txn.iter_inodes() {

[22.440414]

[22.440461]

    for x in txn.iter_inodes().unwrap() {
        let (inode, vertex) = x.unwrap();

Replacement in libpijul/src/tests/conflict.rs at line 2555 [22.357372]

B:BD[22.440589] → [22.440589:440653]

            if let Some(next) = txn.get_revtree(inode_, None) {

[22.440589]

[22.440653]

            if let Some(next) = txn.get_revtree(inode_, None).unwrap() {

Replacement in libpijul/src/tests/conflict.rs at line 2562 [22.357372]

B:BD[22.440857] → [26.31289:31350]

        if !is_alive(txn, &channel, vertex.inode_vertex()) {

[22.440857]

[26.31350]

        if !is_alive(txn, &channel.graph, vertex.inode_vertex()).unwrap() {

Replacement in libpijul/src/tests/conflict.rs at line 2565 [22.357372]
∅:D[26.31407] → [22.440957:440983]
B:BD[22.440957] → [22.440957:440983]
```
                &channel,
```
[26.31407]
[22.440983]
```
                &channel.graph,
```
Replacement in libpijul/src/tests/conflict.rs at line 2569 [22.357372]
B:BD[22.441092] → [22.441092:441108]
```
            ) {
```
[22.441092]
[22.441108]
```
            )
            .unwrap()
            {
```

Replacement in libpijul/src/tests/clone.rs at line 37 [22.441393]

B:BD[22.442660] → [22.442660:442770]

        for channel in txn.iter_channels("") {
            for (_, (i, _)) in txn.log(&channel.borrow(), 0) {

[22.442660]

[22.442770]

        for channel in txn.iter_channels("").unwrap() {
            let channel = channel.unwrap();
            for x in txn.log(&channel.borrow(), 0).unwrap() {
                let (_, (i, _)) = x.unwrap();

Replacement in libpijul/src/tests/change.rs at line 48 [22.446445]
B:BD[22.448033] → [22.448033:448059]
```
            &mut channel,
```
[22.448033]
[22.448059]
```
            &mut channel.borrow_mut(),
```
Replacement in libpijul/src/tests/change.rs at line 58 [22.446445]
B:BD[22.448245] → [22.448245:448285]
```
        .map(|rec| rec.globalize(&txn))
```
[22.448245]
[22.448285]
```
        .map(|rec| rec.globalize(&txn).unwrap())
```
Replacement in libpijul/src/tests/change.rs at line 73 [22.446445]
B:BD[22.448681] → [22.448681:448688]
```
    );
```
[22.448681]
[22.448688]
```
    )
    .unwrap();
```

Replacement in libpijul/src/tests/change.rs at line 96 [22.446445]

B:BD[22.449161] → [22.449161:449237]

    state.record(txn, Algorithm::default(), channel, repo, store, prefix)?;

[22.449161]

[22.449237]

    state.record(
        txn,
        Algorithm::default(),
        &mut channel.borrow_mut(),
        repo,
        store,
        prefix,
    )?;

Replacement in libpijul/src/tests/change.rs at line 109 [22.446445]
B:BD[22.449328] → [22.449328:449367]
```
        .map(|rec| rec.globalize(txn))
```
[22.449328]
[22.449367]
```
        .map(|rec| rec.globalize(txn).unwrap())
```
Replacement in libpijul/src/tests/change.rs at line 126 [22.446445]
B:BD[22.449926] → [22.449926:449933]
```
    );
```
[22.449926]
[22.449933]
```
    )
    .unwrap();
```
Replacement in libpijul/src/tests/add_file.rs at line 29 [22.454125]
B:BD[22.455055] → [22.455055:455090]
```
            .map(|(_, name)| name)
```
[22.455055]
[22.455090]
```
            .map(|n| n.unwrap().1)
```

Replacement in libpijul/src/tests/add_file.rs at line 33 [22.454125]

B:BD[22.455167] → [22.455167:455225]

        let channel_ = txn.load_channel("main").unwrap();

[22.455167]

[22.455225]

        let channel_ = txn.load_channel("main").unwrap().unwrap();

Replacement in libpijul/src/tests/add_file.rs at line 35 [22.454125]

B:BD[22.455266] → [22.455266:455413]

        let mut it = crate::fs::iter_graph_children(&txn, &changes, &channel, Position::ROOT);
        let (key, meta, file) = it.next().unwrap();

[22.455266]

[22.455413]

        let mut it =
            crate::fs::iter_graph_children(&txn, &changes, &channel.graph, Position::ROOT).unwrap();
        let (key, meta, file) = it.next().unwrap().unwrap();

Replacement in libpijul/src/tests/add_file.rs at line 41 [22.454125]

B:BD[22.455516] → [22.455516:455717]

        let mut it = crate::fs::iter_graph_children(&txn, &changes, &channel, key);
        let (file_key, _, _) = it.next().unwrap();
        crate::fs::iter_paths(&txn, &channel_, file_key, |path| {

[22.455516]

[22.455717]

        let mut it = crate::fs::iter_graph_children(&txn, &changes, &channel.graph, key).unwrap();
        let (file_key, _, _) = it.next().unwrap().unwrap();
        crate::fs::iter_paths(&txn, &channel_.borrow().graph, file_key, |path| {

Replacement in libpijul/src/tests/add_file.rs at line 50 [22.454125]
B:BD[22.455890] → [22.455890:455902]
```
        });
```
[22.455890]
[26.31734]
```
        })
        .unwrap();
```

Replacement in libpijul/src/tests/add_file.rs at line 54 [22.454125]

B:BD[22.455960] → [22.455960:456088]

        let mut it = crate::fs::iter_basenames(&txn, &changes, &channel, key);
        let (key, _, name) = it.next().unwrap();

[22.455960]

[22.456088]

        let mut it = crate::fs::iter_basenames(&txn, &changes, &channel.graph, key).unwrap();
        let (key, _, name) = it.next().unwrap().unwrap();

Replacement in libpijul/src/tests/add_file.rs at line 59 [22.454125]
B:BD[22.456200] → [22.456200:456245]
```
        assert!(txn.is_tracked("dir/file"));
```
[22.456200]
[22.456245]
```
        assert!(txn.is_tracked("dir/file").unwrap());
```

Replacement in libpijul/src/tests/add_file.rs at line 76 [22.454125]

B:BD[22.456669] → [22.456669:456746]

    assert!(txn.is_tracked("dir"));
    assert!(txn.is_tracked("dir/file"));

[22.456669]

[22.456746]

    assert!(txn.is_tracked("dir").unwrap());
    assert!(txn.is_tracked("dir/file").unwrap());

Insertion in libpijul/src/tests/add_file.rs at line 80 [22.454125]
[22.456823]
[22.456823]
```
        .unwrap()
```
Insertion in libpijul/src/tests/add_file.rs at line 82 [22.454125]
[22.456839]
[22.456839]
```
        .unwrap()
```
Replacement in libpijul/src/tests/add_file.rs at line 85 [22.454125]
B:BD[22.456896] → [22.456896:456934]
```
    assert!(txn.is_directory(inode));
```
[22.456896]
[22.456934]
```
    assert!(txn.is_directory(inode).unwrap());
```

Replacement in libpijul/src/tests/add_file.rs at line 88 [22.454125]

∅:D[26.31831] → [22.457003:457107]

B:BD[22.457003] → [22.457003:457107]

    let mut it = crate::fs::working_copy_children(&txn, inode);
    let (name, _) = it.next().unwrap();

[26.31831]

[22.457107]

    let mut it = crate::fs::working_copy_children(&txn, inode).unwrap();
    let (name, _) = it.next().unwrap().unwrap();

Replacement in libpijul/src/tests/add_file.rs at line 114 [22.454125]
B:BD[22.457925] → [22.457925:457960]
```
            .map(|(_, file)| file)
```
[22.457925]
[22.457960]
```
            .map(|f| f.unwrap().1)
```
Replacement in libpijul/src/tests/add_file.rs at line 122 [22.454125]
B:BD[22.458186] → [22.458186:458221]
```
            .map(|(_, name)| name)
```
[22.458186]
[22.458221]
```
            .map(|n| n.unwrap().1)
```
Replacement in libpijul/src/tests/add_file.rs at line 131 [22.454125]
B:BD[22.458529] → [22.458529:458564]
```
            .map(|(_, name)| name)
```
[22.458529]
[22.458564]
```
            .map(|n| n.unwrap().1)
```

Replacement in libpijul/src/tests/add_file.rs at line 139 [22.454125]

B:BD[22.458778] → [22.458778:458876]

        assert!(crate::fs::iter_working_copy(&txn, Inode::ROOT).all(|(_, file)| file != "dir2"));

[22.458778]

[22.458876]

        assert!(crate::fs::iter_working_copy(&txn, Inode::ROOT).all(|f| f.unwrap().1 != "dir2"));

Replacement in libpijul/src/tests/add_file.rs at line 147 [22.454125]
B:BD[22.459075] → [22.459075:459110]
```
            .map(|(_, name)| name)
```
[22.459075]
[22.459110]
```
            .map(|n| n.unwrap().1)
```
Replacement in libpijul/src/tests/add_file.rs at line 172 [22.454125]
B:BD[29.3597] → [29.3597:3628]
```
        .map(|(_, file)| file)
```
[29.3597]
[29.3628]
```
        .map(|f| f.unwrap().1)
```
Replacement in libpijul/src/tests/add_file.rs at line 186 [22.454125]
B:BD[29.4203] → [29.4203:4234]
```
        .map(|(_, name)| name)
```
[29.4203]
[29.4234]
```
        .map(|n| n.unwrap().1)
```
Replacement in libpijul/src/tests/add_file.rs at line 673 [22.454125]
B:BD[22.475569] → [22.475569:475591]
```
        &mut channel,
```
[22.475569]
[22.475591]
```
        &mut channel.borrow_mut(),
```
Replacement in libpijul/src/tests/add_file.rs at line 682 [22.454125]
B:BD[22.475762] → [22.475762:475784]
```
        &mut channel,
```
[22.475762]
[22.475784]
```
        &mut channel.borrow_mut(),
```
Replacement in libpijul/src/tests/add_file.rs at line 692 [22.454125]
B:BD[22.475943] → [22.475943:475989]
```
        .map(|rec| rec.globalize(&txn_alice))
```
[22.475943]
[22.475989]
```
        .map(|rec| rec.globalize(&txn_alice).unwrap())
```
Replacement in libpijul/src/tests/add_file.rs at line 706 [22.454125]
B:BD[22.476345] → [22.476345:476352]
```
    );
```
[22.476345]
[22.476352]
```
    )
    .unwrap();
```

Replacement in libpijul/src/tests/add_file.rs at line 720 [22.454125]

B:BD[22.476642] → [26.33753:33817]

    let (alive, reachable) = check_alive(&txn_alice, &channel);

[22.476642]

[22.476704]

    let (alive, reachable) = check_alive(&txn_alice, &channel.borrow().graph);

Replacement in libpijul/src/tests/add_file.rs at line 774 [22.454125]
B:BD[22.478478] → [22.478478:478513]
```
            .map(|(_, name)| name)
```
[22.478478]
[22.478513]
```
            .map(|n| n.unwrap().1)
```
Replacement in libpijul/src/tests/add_file.rs at line 795 [22.454125]
B:BD[22.479182] → [22.479182:479217]
```
            .map(|(_, name)| name)
```
[22.479182]
[22.479217]
```
            .map(|n| n.unwrap().1)
```
Replacement in libpijul/src/record.rs at line 28 [22.488880]
B:BD[23.11461] → [23.11461:11499]
```
    Diff(#[from] diff::DiffError<C>),
```
[23.11461]
[23.11499]
```
    Diff(#[from] diff::DiffError<C, T>),
```

Insertion in libpijul/src/record.rs at line 35 [22.488880]

[22.489268]

impl<
        C: std::error::Error + 'static,
        W: std::error::Error + 'static,
        T: std::error::Error + 'static,
    > std::convert::From<TxnErr<T>> for RecordError<C, W, T>
{
    fn from(e: TxnErr<T>) -> Self {
        RecordError::Txn(e.0)
    }
}

Replacement in libpijul/src/record.rs at line 150 [22.488880]

B:BD[22.492241] → [22.492241:492397]

fn get_inodes<T: TxnT>(txn: &T, channel: &Channel<T>, inode: Inode) -> Option<Position<ChangeId>> {
    if let Some(vertex) = txn.get_inodes(inode, None) {

[22.492241]

[22.492397]

fn get_inodes<T: ChannelTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>>(
    txn: &T,
    channel: &Channel<T>,
    inode: Inode,
) -> Result<Option<Position<ChangeId>>, TxnErr<T::GraphError>> {
    if let Some(vertex) = txn.get_inodes(inode, None)? {

Replacement in libpijul/src/record.rs at line 157 [22.488880]

B:BD[22.492412] → [22.492412:492478]

            .get_changeset(&channel.changes, vertex.change, None)

[22.492412]

[22.492478]

            .get_changeset(&channel.changes, vertex.change, None)?

Replacement in libpijul/src/record.rs at line 160 [22.488880]
B:BD[22.492511] → [22.492511:492536]
```
            Some(vertex)
```
[22.492511]
[22.492536]
```
            Ok(Some(vertex))
```
Replacement in libpijul/src/record.rs at line 162 [22.488880]
B:BD[22.492553] → [22.492553:492570]
```
            None
```
[22.492553]
[22.492570]
```
            Ok(None)
```
Replacement in libpijul/src/record.rs at line 165 [22.488880]
B:BD[22.492593] → [22.492593:492606]
```
        None
```
[22.492593]
[22.492606]
```
        Ok(None)
```

Replacement in libpijul/src/record.rs at line 170 [22.488880]

B:BD[22.492630] → [22.492630:492700]

    pub(crate) fn record<T: MutTxnT, W: WorkingCopy, C: ChangeStore>(

[22.492630]

[22.492700]

    pub(crate) fn record<T, W: WorkingCopy, C: ChangeStore>(

Replacement in libpijul/src/record.rs at line 174 [22.488880]
B:BD[22.492781] → [22.492781:492818]
```
        channel: &mut ChannelRef<T>,
```
[22.492781]
[22.492818]
```
        channel: &mut Channel<T>,
```

Replacement in libpijul/src/record.rs at line 178 [22.488880]

B:BD[22.492891] → [23.11631:11696]

    ) -> Result<(), RecordError<C::Error, W::Error, T::Error>> {

[22.492891]

[22.492928]

    ) -> Result<(), RecordError<C::Error, W::Error, T::GraphError>>
    where
        T: ChannelTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError> + GraphMutTxnT,
        <W as WorkingCopy>::Error: 'static,
    {

Deletion in libpijul/src/record.rs at line 184 [22.488880]
B:BD[22.492973] → [22.492973:493013]
```
        let channel = channel.borrow();
```
Replacement in libpijul/src/record.rs at line 196 [22.488880]
B:BD[22.493559] → [22.493559:493589]
```
                    &channel,
```
[22.493559]
[22.493589]
```
                    &channel.graph,
```
Replacement in libpijul/src/record.rs at line 200 [22.488880]
B:BD[22.493696] → [22.493696:493715]
```
                );
```
[22.493696]
[22.493715]
```
                )?;
```

Replacement in libpijul/src/record.rs at line 202 [22.488880]

B:BD[22.493753] → [22.493753:493834]

            } else if let Some(vertex) = get_inodes(txn, &channel, item.inode) {

[22.493753]

[22.493834]

            } else if let Some(vertex) = get_inodes(txn, &channel, item.inode)? {

Replacement in libpijul/src/record.rs at line 333 [22.488880]

B:BD[22.499383] → [22.499383:499456]

    fn record_existing_file<T: MutTxnT, W: WorkingCopy, C: ChangeStore>(

[22.499383]

[22.499456]

    fn record_existing_file<
        T: ChannelTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
        W: WorkingCopy,
        C: ChangeStore,
    >(

Replacement in libpijul/src/record.rs at line 346 [22.488880]

B:BD[22.499681] → [23.11806:11871]

    ) -> Result<(), RecordError<C::Error, W::Error, T::Error>> {

[22.499681]

[22.499718]

    ) -> Result<(), RecordError<C::Error, W::Error, T::GraphError>>
    where
        <W as crate::working_copy::WorkingCopy>::Error: 'static,
    {

Replacement in libpijul/src/record.rs at line 359 [22.488880]

B:BD[22.500045] → [26.33988:34069]

∅:D[26.34069] → [22.500138:500208]

B:BD[22.500138] → [22.500138:500208]

        for name_ in iter_adjacent(txn, &channel, vertex.inode_vertex(), f0, f1)
            .filter(|e| e.flag.contains(EdgeFlags::PARENT))
        {

[22.500045]

[22.500208]

        for name_ in iter_adjacent(txn, &channel.graph, vertex.inode_vertex(), f0, f1)? {
            let name_ = name_?;
            if !name_.flag.contains(EdgeFlags::PARENT) {
                continue;
            }

Replacement in libpijul/src/record.rs at line 370 [22.488880]

B:BD[22.500452] → [26.34070:34150]

            let name_dest = find_block_end(txn, &channel, name_.dest).unwrap();

[22.500452]

[22.500531]

            let name_dest = find_block_end(txn, &channel.graph, name_.dest).unwrap();

Replacement in libpijul/src/record.rs at line 373 [22.488880]

B:BD[23.11892] → [23.11892:11969]

                .get_contents(|p| txn.get_external(p), name_dest, &mut name)

[23.11892]

[23.11969]

                .get_contents(|p| txn.get_external(p).unwrap(), name_dest, &mut name)

Replacement in libpijul/src/record.rs at line 379 [22.488880]

B:BD[22.500926] → [26.34151:34242]

            if let Some(v_papa) = iter_adjacent(txn, &channel, name_dest, f0, f1).next() {

[22.500926]

[22.501016]

            if let Some(v_papa) = iter_adjacent(txn, &channel.graph, name_dest, f0, f1)?.next() {
                let v_papa = v_papa?;

Replacement in libpijul/src/record.rs at line 404 [22.488880]

B:BD[22.501992] → [22.501992:502032]

                self.record_moved_file(

[22.501992]

[22.502032]

                self.record_moved_file::<_, _, W>(

Replacement in libpijul/src/record.rs at line 407 [22.488880]
B:BD[22.502086] → [22.502086:502116]
```
                    &channel,
```
[22.502086]
[22.502116]
```
                    &channel.graph,
```

Replacement in libpijul/src/record.rs at line 412 [22.488880]

B:BD[22.502254] → [23.12023:12093]

                )
                .map_err(RecordError::Changestore)?

[22.502254]

[22.502273]

)?

Replacement in libpijul/src/record.rs at line 418 [22.488880]

B:BD[22.502466] → [22.502466:502529]

                let mut ret = retrieve(txn, &channel, vertex);

[22.502466]

[22.502529]

                let mut ret = retrieve(txn, &channel.graph, vertex)?;

Replacement in libpijul/src/record.rs at line 443 [22.488880]

B:BD[22.503210] → [22.503210:503301]

            self.record_deleted_file(txn, &channel, working_copy, &item.full_path, vertex)

[22.503210]

[22.503301]

            self.record_deleted_file(txn, &channel.graph, working_copy, &item.full_path, vertex)?

Replacement in libpijul/src/record.rs at line 448 [22.488880]

B:BD[22.503333] → [8.383:444]

    fn delete_obsolete_children<T: MutTxnT, W: WorkingCopy>(

[22.503333]

[22.503398]

    fn delete_obsolete_children<
        T: GraphTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
        W: WorkingCopy,
    >(

Replacement in libpijul/src/record.rs at line 454 [22.488880]
B:BD[22.503434] → [22.503434:503464]
```
        channel: &Channel<T>,
```
[22.503434]
[22.503464]
```
        channel: &T::Graph,
```
Replacement in libpijul/src/record.rs at line 458 [22.488880]
B:BD[22.503546] → [22.503546:503554]
```
    ) {
```
[22.503546]
[22.503554]
```
    ) -> Result<(), TxnErr<T::GraphError>> {
```

Replacement in libpijul/src/record.rs at line 462 [22.488880]

B:BD[22.503681] → [26.34243:34469]

        for child in iter_adjacent(txn, &channel, v.inode_vertex(), f0, f1) {
            let child = find_block(txn, &channel, child.dest).unwrap();
            for grandchild in iter_adjacent(txn, &channel, child, f0, f1) {

[22.503681]

[22.503904]

        for child in iter_adjacent(txn, channel, v.inode_vertex(), f0, f1)? {
            let child = child?;
            let child = find_block(txn, channel, child.dest).unwrap();
            for grandchild in iter_adjacent(txn, channel, child, f0, f1)? {
                let grandchild = grandchild?;

Replacement in libpijul/src/record.rs at line 468 [22.488880]

B:BD[22.503959] → [22.503959:504146]

B:BD[22.504146] → [5.0:147]

                let needs_deletion = if let Some(inode) = txn.get_revinodes(grandchild.dest, None) {
                    debug!("inode = {:?} {:?}", inode, txn.get_revtree(inode, None));
                    if let Some(path) = crate::fs::inode_filename(txn, inode) {
                        working_copy.file_metadata(&path).is_err()

[22.503959]

[5.147]

                let needs_deletion =
                    if let Some(inode) = txn.get_revinodes(grandchild.dest, None)? {
                        debug!("inode = {:?} {:?}", inode, txn.get_revtree(inode, None));
                        if let Some(path) = crate::fs::inode_filename(txn, inode)? {
                            working_copy.file_metadata(&path).is_err()
                        } else {
                            true
                        }

Replacement in libpijul/src/record.rs at line 478 [22.488880]

B:BD[5.205] → [5.205:227]

∅:D[5.227] → [22.504205:504274]

B:BD[22.504205] → [22.504205:504274]

[5.205]

[22.504274]

};

Replacement in libpijul/src/record.rs at line 487 [22.488880]
B:BD[22.504576] → [22.504576:504598]
```
                    )
```
[22.504576]
[22.504598]
```
                    )?
```
Insertion in libpijul/src/record.rs at line 491 [22.488880]
[22.504640]
[22.504640]
```
        Ok(())
```

Replacement in libpijul/src/record.rs at line 494 [22.488880]

B:BD[22.504647] → [23.12237:12307]

    fn push_children<'a, T: MutTxnT, W: WorkingCopy, C: ChangeStore>(

[22.504647]

[22.504701]

    fn push_children<
        'a,
        T: ChannelTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
        W: WorkingCopy,
        C: ChangeStore,
    >(

Replacement in libpijul/src/record.rs at line 508 [22.488880]

B:BD[22.504935] → [23.12308:12373]

    ) -> Result<(), RecordError<C::Error, W::Error, T::Error>> {

[22.504935]

[22.504972]

    ) -> Result<(), RecordError<C::Error, W::Error, T::GraphError>>
    where
        <W as crate::working_copy::WorkingCopy>::Error: 'static,
    {

Replacement in libpijul/src/record.rs at line 519 [22.488880]

B:BD[22.505236] → [22.505236:505312]

        for (fileid_, child_inode) in txn.iter_tree(fileid.clone(), None) {

[22.505236]

[22.505312]

        for x in txn.iter_tree(fileid.clone(), None)? {
            let (fileid_, child_inode) = x?;

Replacement in libpijul/src/record.rs at line 549 [22.488880]

B:BD[22.506445] → [22.506445:506617]

            } else if let Some(vertex) = get_inodes(txn, &channel, child_inode) {
                self.record_deleted_file(txn, &channel, working_copy, &full_path, vertex)

[22.506445]

[22.506617]

            } else if let Some(vertex) = get_inodes(txn, &channel, child_inode)? {
                self.record_deleted_file(txn, &channel.graph, working_copy, &full_path, vertex)?

Replacement in libpijul/src/record.rs at line 561 [22.488880]
B:BD[22.506910] → [22.506910:506966]
```
fn modified_since_last_commit<T: TxnT, W: WorkingCopy>(
```
[22.506855]
[22.506966]
```
fn modified_since_last_commit<T: ChannelTxnT, W: WorkingCopy>(
```

Replacement in libpijul/src/record.rs at line 585 [22.488880]

B:BD[22.507625] → [22.507625:507676]

    fn record_moved_file<T: TxnT, C: ChangeStore>(

[22.507625]

[22.507676]

    fn record_moved_file<T: GraphTxnT, C: ChangeStore, W: WorkingCopy>(

Replacement in libpijul/src/record.rs at line 589 [22.488880]
B:BD[22.507733] → [22.507733:507763]
```
        channel: &Channel<T>,
```
[22.507733]
[22.507763]
```
        channel: &T::Graph,
```

Replacement in libpijul/src/record.rs at line 594 [22.488880]

B:BD[22.507905] → [23.12496:12528]

    ) -> Result<(), C::Error> {

[22.507905]

[22.507942]

    ) -> Result<(), RecordError<C::Error, W::Error, T::GraphError>>
    where
        <W as crate::working_copy::WorkingCopy>::Error: 'static,
    {

Replacement in libpijul/src/record.rs at line 605 [22.488880]
B:BD[22.508507] → [22.508507:508552]
```
        let mut moved = collect_moved_edges(
```
[22.508444]
[22.508552]
```
        let mut moved = collect_moved_edges::<_, _, W>(
```
Replacement in libpijul/src/record.rs at line 672 [22.488880]
B:BD[22.510763] → [22.510763:510812]
```
fn collect_moved_edges<T: TxnT, C: ChangeStore>(
```
[22.510763]
[22.510812]
```
fn collect_moved_edges<T: GraphTxnT, C: ChangeStore, W: WorkingCopy>(
```
Replacement in libpijul/src/record.rs at line 675 [22.488880]
B:BD[22.510842] → [22.510842:510868]
```
    channel: &Channel<T>,
```
[22.510842]
[22.510868]
```
    channel: &T::Graph,
```

Replacement in libpijul/src/record.rs at line 681 [22.488880]

B:BD[22.511024] → [23.12592:12628]

) -> Result<MovedEdges, C::Error> {

[22.511024]

[22.511065]

) -> Result<MovedEdges, RecordError<C::Error, W::Error, T::GraphError>>
where
    <W as crate::working_copy::WorkingCopy>::Error: 'static,
{

Replacement in libpijul/src/record.rs at line 701 [22.488880]

B:BD[26.34642] → [26.34642:34720]

∅:D[26.34720] → [22.511660:511666]

B:BD[22.511660] → [22.511660:511666]

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

[26.34642]

[22.511729]

    )? {
        let parent = parent?;
        if !parent.flag.contains(EdgeFlags::FOLDER | EdgeFlags::PARENT) {
            continue;
        }

Replacement in libpijul/src/record.rs at line 730 [22.488880]

B:BD[22.512793] → [26.34721:34800]

∅:D[26.34800] → [22.512871:512960]

B:BD[22.512871] → [22.512871:512960]

        let parent_dest = find_block_end(txn, &channel, parent.dest).unwrap();
        changes.get_contents(|p| txn.get_external(p), parent_dest, &mut previous_name)?;

[22.512793]

[22.512960]

        let parent_dest = find_block_end(txn, channel, parent.dest).unwrap();
        changes
            .get_contents(
                |p| txn.get_external(p).unwrap(),
                parent_dest,
                &mut previous_name,
            )
            .map_err(RecordError::Changestore)?;

Replacement in libpijul/src/record.rs at line 752 [22.488880]

B:BD[26.34987] → [26.34987:35154]

        )
        .filter(|e| {
            e.flag.contains(EdgeFlags::FOLDER | EdgeFlags::PARENT)
                && !e.flag.contains(EdgeFlags::PSEUDO)
        }) {

[26.34987]

[22.513762]

        )? {
            let grandparent = grandparent?;
            if !grandparent
                .flag
                .contains(EdgeFlags::FOLDER | EdgeFlags::PARENT)
                || grandparent.flag.contains(EdgeFlags::PSEUDO)
            {
                continue;
            }

Replacement in libpijul/src/record.rs at line 762 [22.488880]

B:BD[22.513816] → [26.35155:35248]

            let grandparent_dest = find_block_end(txn, &channel, grandparent.dest).unwrap();

[22.513816]

[22.513908]

            let grandparent_dest = find_block_end(txn, channel, grandparent.dest).unwrap();

Replacement in libpijul/src/record.rs at line 864 [22.488880]

B:BD[22.518341] → [22.518341:518394]

    fn record_deleted_file<T: TxnT, W: WorkingCopy>(

[22.518341]

[22.518394]

    fn record_deleted_file<
        T: GraphTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
        W: WorkingCopy,
    >(

Replacement in libpijul/src/record.rs at line 870 [22.488880]
B:BD[22.518430] → [22.518430:518460]
```
        channel: &Channel<T>,
```
[22.518430]
[22.518460]
```
        channel: &T::Graph,
```
Replacement in libpijul/src/record.rs at line 874 [22.488880]
B:BD[22.518555] → [22.518555:518563]
```
    ) {
```
[22.518555]
[22.518563]
```
    ) -> Result<(), TxnErr<T::GraphError>> {
```

Replacement in libpijul/src/record.rs at line 880 [22.488880]

B:BD[22.518868] → [26.35249:35318]

            if let Some(path) = tree_path(txn, vertex.start_pos()) {

[22.518868]

[22.518936]

            if let Some(path) = tree_path(txn, vertex.start_pos())? {

Replacement in libpijul/src/record.rs at line 889 [22.488880]

B:BD[22.519190] → [22.519190:519257]

                self.delete_file_edge(txn, channel, vertex, inode)

[22.519190]

[39.3339]

                self.delete_file_edge(txn, channel, vertex, inode)?

Replacement in libpijul/src/record.rs at line 896 [22.488880]

B:BD[39.3605] → [39.3605:3688]

                if let Some(inode) = txn.get_revinodes(vertex.start_pos(), None) {

[39.3605]

[39.3688]

                if let Some(inode) = txn.get_revinodes(vertex.start_pos(), None)? {

Replacement in libpijul/src/record.rs at line 907 [22.488880]

B:BD[22.520253] → [39.4120:4214]

                self.delete_inode_vertex(txn, channel, vertex, vertex.start_pos(), full_path)

[22.520253]

                self.delete_inode_vertex(txn, channel, vertex, vertex.start_pos(), full_path)?

Replacement in libpijul/src/record.rs at line 917 [22.488880]
B:BD[22.520514] → [22.520514:520530]
```
            ) {
```
[22.520514]
[22.520530]
```
            )? {
                let edge = edge?;
```

Replacement in libpijul/src/record.rs at line 921 [22.488880]

B:BD[26.35407] → [26.35407:35507]

                    find_block(txn, &channel, edge.dest).expect("delete_recursively, descendants");

[26.35407]

[22.520742]

                    find_block(txn, channel, edge.dest).expect("delete_recursively, descendants");

Insertion in libpijul/src/record.rs at line 936 [22.488880]
[22.521259]
[22.521259]
```
        Ok(())
```
Replacement in libpijul/src/record.rs at line 939 [22.488880]
B:BD[22.521266] → [22.521266:521303]
```
    fn delete_inode_vertex<T: TxnT>(
```
[22.521266]
[22.521303]
```
    fn delete_inode_vertex<T: GraphTxnT>(
```
Replacement in libpijul/src/record.rs at line 942 [22.488880]
B:BD[22.521339] → [22.521339:521369]
```
        channel: &Channel<T>,
```
[22.521339]
[22.521369]
```
        channel: &T::Graph,
```
Replacement in libpijul/src/record.rs at line 946 [22.488880]
B:BD[22.521458] → [22.521458:521466]
```
    ) {
```
[22.521458]
[22.521466]
```
    ) -> Result<(), TxnErr<T::GraphError>> {
```

Replacement in libpijul/src/record.rs at line 954 [22.488880]

B:BD[26.35684] → [26.35684:35822]

        )
        .filter(|e| e.flag.contains(EdgeFlags::PARENT))
        {
            assert!(parent.flag.contains(EdgeFlags::PARENT));

[26.35684]

[26.35822]

        )? {
            let parent = parent?;
            if !parent.flag.contains(EdgeFlags::PARENT) {
                continue;
            }

Replacement in libpijul/src/record.rs at line 960 [22.488880]

B:BD[26.35884] → [26.35884:35967]

            let parent_dest = find_block_end(txn, &channel, parent.dest).unwrap();

[26.35884]

[26.35967]

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

Replacement in libpijul/src/record.rs at line 967 [22.488880]

B:BD[22.521694] → [22.521694:521708]

B:BD[22.521708] → [26.36065:36164]

∅:D[26.36164] → [22.522371:522385]

B:BD[22.522371] → [22.522371:522385]

            )
            .filter(|e| e.flag.contains(EdgeFlags::PARENT) && !e.flag.contains(EdgeFlags::PSEUDO))
            {

[22.521694]

[22.522385]

            )? {
                let grandparent = grandparent?;
                if !grandparent.flag.contains(EdgeFlags::PARENT)
                    || grandparent.flag.contains(EdgeFlags::PSEUDO)
                {
                    continue;
                }

Insertion in libpijul/src/record.rs at line 1005 [22.488880]
[22.523734]
[22.523734]
```
        Ok(())
```
Replacement in libpijul/src/record.rs at line 1008 [22.488880]
B:BD[22.523741] → [22.523741:523775]
```
    fn delete_file_edge<T: TxnT>(
```
[22.523741]
[22.523775]
```
    fn delete_file_edge<T: GraphTxnT>(
```
Replacement in libpijul/src/record.rs at line 1011 [22.488880]
B:BD[22.523811] → [22.523811:523841]
```
        channel: &Channel<T>,
```
[22.523811]
[22.523841]
```
        channel: &T::Graph,
```
Replacement in libpijul/src/record.rs at line 1014 [22.488880]
B:BD[22.523906] → [22.523906:523914]
```
    ) {
```
[22.523906]
[22.523914]
```
    ) -> Result<(), TxnErr<T::GraphError>> {
```

Replacement in libpijul/src/record.rs at line 1032 [22.488880]

B:BD[26.36386] → [26.36386:36469]

∅:D[26.36469] → [22.524640:524658]

B:BD[22.524640] → [22.524640:524658]

                )
                .filter(|e| !e.flag.contains(EdgeFlags::PSEUDO))
                {

[26.36386]

[22.524658]

                )? {
                    let parent = parent?;
                    if parent.flag.contains(EdgeFlags::PSEUDO) {
                        continue;
                    }

Insertion in libpijul/src/record.rs at line 1049 [22.488880]
[22.525209]
[22.525209]
```
        Ok(())
```

Insertion in libpijul/src/pristine/sanakirja.rs at line 28 [22.531056]

[23.12924]

}
impl std::convert::From<::sanakirja::CRCError> for SanakirjaError {
    fn from(_: ::sanakirja::CRCError) -> Self {
        SanakirjaError::PristineCorrupt
    }
}
impl std::convert::From<::sanakirja::CRCError> for TxnErr<SanakirjaError> {
    fn from(_: ::sanakirja::CRCError) -> Self {
        TxnErr(SanakirjaError::PristineCorrupt)
    }
}
impl std::convert::From<::sanakirja::Error> for TxnErr<SanakirjaError> {
    fn from(e: ::sanakirja::Error) -> Self {
        TxnErr(e.into())
    }
}
impl std::convert::From<TxnErr<::sanakirja::Error>> for TxnErr<SanakirjaError> {
    fn from(e: TxnErr<::sanakirja::Error>) -> Self {
        TxnErr(e.0.into())
    }

Replacement in libpijul/src/pristine/sanakirja.rs at line 278 [22.531056]

B:BD[22.539439] → [22.539439:539516]

        for (a, (g, c, r, s, _, _)) in self.txn.iter(&self.channels, None) {

[22.539439]

[22.539516]

        for x in self.txn.iter(&self.channels, None).unwrap() {
            let (a, (g, c, r, s, _, _)) = x.unwrap();

Replacement in libpijul/src/pristine/sanakirja.rs at line 292 [22.531056]

B:BD[22.540004] → [22.540004:540071]

        for (a, (u, v, w)) in self.txn.iter(&self.remotes, None) {

[22.540004]

[22.540071]

        for x in self.txn.iter(&self.remotes, None).unwrap() {
            let (a, (u, v, w)) = x.unwrap();

Replacement in libpijul/src/pristine/sanakirja.rs at line 309 [22.531056]

B:BD[22.540597] → [22.540597:540674]

        for (a, (g, c, r, s, _, _)) in self.txn.iter(&self.channels, None) {

[22.540597]

[22.540674]

        for x in self.txn.iter(&self.channels, None).unwrap() {
            let (a, (g, c, r, s, _, _)) = x.unwrap();

Replacement in libpijul/src/pristine/sanakirja.rs at line 356 [22.531056]
B:BD[22.542222] → [22.542222:542281]
B:BD[22.542281] → [23.13666:13699]
```
impl<T: ::sanakirja::Transaction> TxnT for GenericTxn<T> {
    type Error = SanakirjaError;
```
[22.542222]
[22.542300]
```
impl<T: ::sanakirja::Transaction> GraphTxnT for GenericTxn<T> {
```
Insertion in libpijul/src/pristine/sanakirja.rs at line 358 [22.531056]
[22.542345]
[22.542345]
```
    type GraphError = SanakirjaError;
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 361 [22.531056]

B:BD[22.542403] → [22.542403:542455]

B:BD[22.542474] → [22.542474:542532]

    sanakirja_get!(graph, Vertex<ChangeId>, Edge);
    fn get_external(&self, p: ChangeId) -> Option<Hash> {

[22.542403]

[22.542532]

    sanakirja_get!(graph, Vertex<ChangeId>, Edge, GraphError);
    fn get_external(&self, p: ChangeId) -> Result<Option<Hash>, TxnErr<Self::GraphError>> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 364 [22.531056]

B:BD[22.542557] → [22.542557:542586]

            Some(Hash::None)

[22.542557]

[22.542586]

            Ok(Some(Hash::None))
        } else if let Ok(x) = self.txn.get(&self.external, p, None) {
            Ok(x)

Replacement in libpijul/src/pristine/sanakirja.rs at line 368 [22.531056]
B:BD[22.542603] → [22.542603:542653]
```
            self.txn.get(&self.external, p, None)
```
[22.542603]
[22.542653]
```
            Err(TxnErr(SanakirjaError::PristineCorrupt))
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 372 [22.531056]
∅:D[26.36940] → [22.542688:542746]
B:BD[22.542688] → [22.542688:542746]
```
    fn get_internal(&self, p: Hash) -> Option<ChangeId> {
```
[26.36940]
[22.542746]
```
    fn get_internal(&self, p: Hash) -> Result<Option<ChangeId>, TxnErr<Self::GraphError>> {
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 374 [22.531056]

B:BD[22.542778] → [22.542778:542811]

            Some(ChangeId::ROOT)

[22.542778]

[22.542811]

            Ok(Some(ChangeId::ROOT))
        } else if let Ok(x) = self.txn.get(&self.internal, p, None) {
            Ok(x)

Replacement in libpijul/src/pristine/sanakirja.rs at line 378 [22.531056]
B:BD[22.542828] → [22.542828:542878]
```
            self.txn.get(&self.internal, p, None)
```
[22.542828]
[22.542878]
```
            Err(TxnErr(SanakirjaError::PristineCorrupt))
```
Insertion in libpijul/src/pristine/sanakirja.rs at line 381 [22.531056]
[22.542894]
[22.542894]
```
}
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 383 [22.531056]

B:BD[22.542895] → [23.13700:13794]

∅:D[23.13794] → [22.542980:543067]

B:BD[22.542980] → [22.542980:543067]

B:BD[22.543067] → [23.13795:13865]

∅:D[23.13865] → [22.543147:543716]

B:BD[22.543147] → [22.543147:543716]

B:BD[22.543716] → [23.13866:13948]

∅:D[23.13948] → [22.543884:544005]

B:BD[22.543884] → [22.543884:544005]

B:BD[22.544005] → [23.13949:14014]

∅:D[23.14014] → [22.544126:544136]

B:BD[22.544126] → [22.544126:544136]

    fn hash_from_prefix(&self, s: &str) -> Result<(Hash, ChangeId), super::HashPrefixError> {
        let h = if let Some(h) = Hash::from_prefix(s) {
            h
        } else {
            return Err(super::HashPrefixError::Parse(s.to_string()));
        };
        let mut result = None;
        debug!("h = {:?}", h);
        for (e, i) in self.txn.iter(&self.internal, Some((h, None))) {
            debug!("{:?} {:?}", e, i);
            if e < h {
                continue;
            } else {
                let b32 = e.to_base32();
                debug!("{:?}", b32);
                let (b32, _) = b32.split_at(s.len().min(b32.len()));
                if b32 != s {
                    break;
                } else if result.is_none() {
                    result = Some((e, i))
                } else {
                    return Err(super::HashPrefixError::Ambiguous(s.to_string()));
                }
            }
        }
        if let Some(result) = result {
            Ok(result)
        } else {
            Err(super::HashPrefixError::NotFound(s.to_string()))
        }

[22.542895]

[22.544136]

impl<T: ::sanakirja::Transaction> ChannelTxnT for GenericTxn<T> {
    type Changeset = Db<ChangeId, u64>;
    type Revchangeset = Db<u64, (ChangeId, Merkle)>;
    type Channelstates = Db<Merkle, u64>;
    sanakirja_get!(changeset, ChangeId, u64, GraphError);
    sanakirja_get!(revchangeset, u64, (ChangeId, Merkle), GraphError);
    sanakirja_cursor!(changeset, ChangeId, u64);
    sanakirja_cursor_ref!(revchangeset, u64, (ChangeId, Merkle));
    sanakirja_rev_cursor!(revchangeset, u64, (ChangeId, Merkle));
}
impl<T: ::sanakirja::Transaction> DepsTxnT for GenericTxn<T> {
    type DepsError = SanakirjaError;
    type Dep = Db<ChangeId, ChangeId>;
    type Revdep = Db<ChangeId, ChangeId>;
    sanakirja_table_get!(dep, ChangeId, ChangeId, DepsError);
    sanakirja_table_get!(revdep, ChangeId, ChangeId, DepsError);
    sanakirja_cursor_ref!(dep, ChangeId, ChangeId);
    fn iter_dep_ref<RT: std::ops::Deref<Target = Self> + Clone>(
        txn: RT,
        p: ChangeId,
    ) -> Result<super::Cursor<Self, RT, Self::DepCursor, ChangeId, ChangeId>, TxnErr<Self::DepsError>>
    {
        Self::cursor_dep_ref(txn.clone(), &txn.dep, Some((p, None)))

Insertion in libpijul/src/pristine/sanakirja.rs at line 411 [22.531056]

[22.544142]


    sanakirja_table_get!(touched_files, Position<ChangeId>, ChangeId, DepsError);
    sanakirja_table_get!(rev_touched_files, ChangeId, Position<ChangeId>, DepsError);
    type Touched_files = Db<Position<ChangeId>, ChangeId>;

Replacement in libpijul/src/pristine/sanakirja.rs at line 417 [22.531056]

B:BD[22.544143] → [22.544143:544252]

B:BD[22.544252] → [23.14015:14063]

∅:D[23.14063] → [22.544291:544416]

B:BD[22.544291] → [22.544291:544416]

B:BD[22.544416] → [23.14064:14134]

∅:D[23.14134] → [22.544496:545049]

B:BD[22.544496] → [22.544496:545049]

B:BD[22.545049] → [23.14135:14217]

∅:D[23.14217] → [22.545217:545338]

B:BD[22.545217] → [22.545217:545338]

B:BD[22.545338] → [23.14218:14283]

∅:D[23.14283] → [22.545459:545469]

B:BD[22.545459] → [22.545459:545469]

    fn hash_from_prefix_remote<'txn>(
        &'txn self,
        remote: &RemoteRef<Self>,
        s: &str,
    ) -> Result<Hash, super::HashPrefixError> {
        let remote = remote.borrow();
        let h = if let Some(h) = Hash::from_prefix(s) {
            h
        } else {
            return Err(super::HashPrefixError::Parse(s.to_string()));
        };
        let mut result = None;
        debug!("h = {:?}", h);
        for (e, _) in self.txn.iter(&remote.rev, Some((h, None))) {
            debug!("{:?}", e);
            if e < h {
                continue;
            } else {
                let b32 = e.to_base32();
                debug!("{:?}", b32);
                let (b32, _) = b32.split_at(s.len().min(b32.len()));
                if b32 != s {
                    break;
                } else if result.is_none() {
                    result = Some(e)
                } else {
                    return Err(super::HashPrefixError::Ambiguous(s.to_string()));
                }
            }
        }
        if let Some(result) = result {
            Ok(result)
        } else {
            Err(super::HashPrefixError::NotFound(s.to_string()))
        }

[22.544143]

[22.545469]

    type Rev_touched_files = Db<ChangeId, Position<ChangeId>>;
    sanakirja_iter!(touched_files, Position<ChangeId>, ChangeId);
    sanakirja_iter!(rev_touched_files, ChangeId, Position<ChangeId>);
    fn iter_revdep(
        &self,
        k: ChangeId,
    ) -> Result<
        super::Cursor<Self, &Self, Self::DepCursor, ChangeId, ChangeId>,
        TxnErr<Self::DepsError>,
    > {
        self.cursor_dep(&self.revdep, Some((k, None)))
    }
    fn iter_dep(
        &self,
        k: ChangeId,
    ) -> Result<
        super::Cursor<Self, &Self, Self::DepCursor, ChangeId, ChangeId>,
        TxnErr<Self::DepsError>,
    > {
        self.cursor_dep(&self.dep, Some((k, None)))
    }
    fn iter_touched(
        &self,
        k: Position<ChangeId>,
    ) -> Result<
        super::Cursor<Self, &Self, Self::Touched_filesCursor, Position<ChangeId>, ChangeId>,
        TxnErr<Self::DepsError>,
    > {
        self.cursor_touched_files(&self.touched_files, Some((k, None)))

Insertion in libpijul/src/pristine/sanakirja.rs at line 450 [22.531056]

[22.545476]

[22.545495]

    fn iter_rev_touched(
        &self,
        k: ChangeId,
    ) -> Result<
        super::Cursor<Self, &Self, Self::Rev_touched_filesCursor, ChangeId, Position<ChangeId>>,
        TxnErr<Self::DepsError>,
    > {
        self.cursor_rev_touched_files(&self.rev_touched_files, Some((k, None)))
    }
}
impl<T: ::sanakirja::Transaction> TreeTxnT for GenericTxn<T> {
    type TreeError = SanakirjaError;

Replacement in libpijul/src/pristine/sanakirja.rs at line 465 [22.531056]

∅:D[41.617] → [22.545544:545669]

B:BD[22.545544] → [22.545544:545669]

    sanakirja_table_get!(inodes, Inode, Position<ChangeId>);
    sanakirja_table_get!(revinodes, Position<ChangeId>, Inode);

[41.617]

[22.545701]

    sanakirja_table_get!(inodes, Inode, Position<ChangeId>, TreeError);
    sanakirja_table_get!(revinodes, Position<ChangeId>, Inode, TreeError);

Replacement in libpijul/src/pristine/sanakirja.rs at line 472 [22.531056]

B:BD[22.545820] → [22.545820:545909]

    sanakirja_table_get!(tree, PathId, Inode, (UnsafePathId::from_fileid(key), value),);

[22.545820]

[22.545909]

    sanakirja_table_get!(
        tree,
        PathId,
        Inode,
        TreeError,
        (UnsafePathId::from_fileid(key), value),
    );

Insertion in libpijul/src/pristine/sanakirja.rs at line 513 [22.531056]
[22.546862]
[22.546862]
```
        TreeError,
```
Deletion in libpijul/src/pristine/sanakirja.rs at line 524 [22.531056]
B:BD[22.547109] → [22.547109:547110]
B:BD[22.547129] → [22.547129:547169]
B:BD[22.547169] → [26.36943:36944]
∅:D[26.36944] → [22.547188:547241]
B:BD[22.547188] → [22.547188:547241]
```
    type Changeset = Db<ChangeId, u64>;
    type Revchangeset = Db<u64, (ChangeId, Merkle)>;
```

Deletion in libpijul/src/pristine/sanakirja.rs at line 525 [22.531056]

∅:D[26.36946] → [22.547260:547589]

B:BD[22.547260] → [22.547260:547589]

B:BD[22.547608] → [22.547608:547648]

B:BD[22.547667] → [22.547667:548014]

B:BD[22.548033] → [22.548033:548208]

B:BD[22.548208] → [49.2066:2135]

∅:D[49.2135] → [22.548302:548309]

B:BD[22.548302] → [22.548302:548309]

B:BD[22.548328] → [22.548328:548387]

B:BD[22.548387] → [26.36947:36948]

∅:D[26.36948] → [22.548406:548606]

B:BD[22.548406] → [22.548406:548606]

    type Channelstates = Db<Merkle, u64>;
    sanakirja_get!(changeset, ChangeId, u64);
    sanakirja_get!(revchangeset, u64, (ChangeId, Merkle));
    sanakirja_cursor!(changeset, ChangeId, u64);
    sanakirja_cursor_ref!(revchangeset, u64, (ChangeId, Merkle));
    sanakirja_rev_cursor!(revchangeset, u64, (ChangeId, Merkle));
    type Dep = Db<ChangeId, ChangeId>;
    type Revdep = Db<ChangeId, ChangeId>;
    sanakirja_table_get!(dep, ChangeId, ChangeId);
    sanakirja_table_get!(revdep, ChangeId, ChangeId);
    sanakirja_cursor_ref!(dep, ChangeId, ChangeId);
    sanakirja_table_get!(touched_files, Position<ChangeId>, ChangeId);
    sanakirja_table_get!(rev_touched_files, ChangeId, Position<ChangeId>);
    fn iter_dep_ref<RT: std::ops::Deref<Target = Self> + Clone>(
        txn: RT,
        p: ChangeId,
    ) -> super::Cursor<Self, RT, Self::DepCursor, ChangeId, ChangeId> {
        Self::cursor_dep_ref(txn.clone(), &txn.dep, Some((p, None)))
    }
    type Touched_files = Db<Position<ChangeId>, ChangeId>;
    type Rev_touched_files = Db<ChangeId, Position<ChangeId>>;
    sanakirja_iter!(touched_files, Position<ChangeId>, ChangeId);
    sanakirja_iter!(rev_touched_files, ChangeId, Position<ChangeId>);

Insertion in libpijul/src/pristine/sanakirja.rs at line 540 [22.531056]

[22.549082]

    fn iter_inodes(
        &self,
    ) -> Result<
        super::Cursor<Self, &Self, Self::InodesCursor, Inode, Position<ChangeId>>,
        TxnErr<Self::TreeError>,
    > {
        self.cursor_inodes(&self.inodes, None)
    }
    #[cfg(debug_assertions)]
    fn iter_revinodes(
        &self,
    ) -> Result<
        super::Cursor<Self, &Self, Self::RevinodesCursor, Position<ChangeId>, Inode>,
        TxnErr<SanakirjaError>,
    > {
        self.cursor_revinodes(&self.revinodes, None)
    }
    fn iter_partials<'txn>(
        &'txn self,
        k: &str,
    ) -> Result<
        super::Cursor<Self, &'txn Self, Self::PartialsCursor, SmallString, Position<ChangeId>>,
        TxnErr<SanakirjaError>,
    > {
        let k0 = SmallString::from_str(k);
        self.cursor_partials(&self.partials, Some((k0, None)))
    }
}
impl<T: ::sanakirja::Transaction> TxnT for GenericTxn<T> {
    fn hash_from_prefix(
        &self,
        s: &str,
    ) -> Result<(Hash, ChangeId), super::HashPrefixError<Self::GraphError>> {
        let h = if let Some(h) = Hash::from_prefix(s) {
            h
        } else {
            return Err(super::HashPrefixError::Parse(s.to_string()));
        };
        let mut result = None;
        debug!("h = {:?}", h);
        for x in self
            .txn
            .iter(&self.internal, Some((h, None)))
            .map_err(|e| super::HashPrefixError::Txn(e.into()))?
        {
            let (e, i) = x.map_err(|e| super::HashPrefixError::Txn(e.into()))?;
            debug!("{:?} {:?}", e, i);
            if e < h {
                continue;
            } else {
                let b32 = e.to_base32();
                debug!("{:?}", b32);
                let (b32, _) = b32.split_at(s.len().min(b32.len()));
                if b32 != s {
                    break;
                } else if result.is_none() {
                    result = Some((e, i))
                } else {
                    return Err(super::HashPrefixError::Ambiguous(s.to_string()));
                }
            }
        }
        if let Some(result) = result {
            Ok(result)
        } else {
            Err(super::HashPrefixError::NotFound(s.to_string()))
        }
    }

Insertion in libpijul/src/pristine/sanakirja.rs at line 612 [22.531056]

[22.549083]

    fn hash_from_prefix_remote<'txn>(
        &'txn self,
        remote: &RemoteRef<Self>,
        s: &str,
    ) -> Result<Hash, super::HashPrefixError<Self::GraphError>> {
        let remote = remote.borrow();
        let h = if let Some(h) = Hash::from_prefix(s) {
            h
        } else {
            return Err(super::HashPrefixError::Parse(s.to_string()));
        };
        let mut result = None;
        debug!("h = {:?}", h);
        for x in self
            .txn
            .iter(&remote.rev, Some((h, None)))
            .map_err(|e| super::HashPrefixError::Txn(e.into()))?
        {
            let (e, _) = x.map_err(|e| super::HashPrefixError::Txn(e.into()))?;
            debug!("{:?}", e);
            if e < h {
                continue;
            } else {
                let b32 = e.to_base32();
                debug!("{:?}", b32);
                let (b32, _) = b32.split_at(s.len().min(b32.len()));
                if b32 != s {
                    break;
                } else if result.is_none() {
                    result = Some(e)
                } else {
                    return Err(super::HashPrefixError::Ambiguous(s.to_string()));
                }
            }
        }
        if let Some(result) = result {
            Ok(result)
        } else {
            Err(super::HashPrefixError::NotFound(s.to_string()))
        }
    }

Replacement in libpijul/src/pristine/sanakirja.rs at line 655 [22.531056]

B:BD[22.549091] → [22.549091:549160]

    fn load_channel(&self, name: &str) -> Option<ChannelRef<Self>> {

[22.549091]

[22.549160]

    fn load_channel(
        &self,
        name: &str,
    ) -> Result<Option<ChannelRef<Self>>, TxnErr<Self::GraphError>> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 667 [22.531056]
B:BD[22.549585] → [22.549585:549607]
```
                    )
```
[22.549585]
[22.549607]
```
                    )?
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 682 [22.531056]
B:BD[22.550134] → [22.550134:550167]
```
                    return None;
```
[22.550134]
[22.550167]
```
                    return Ok(None);
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 687 [22.531056]

B:BD[22.550246] → [50.374:430]

        self.open_channels.borrow().get(&name).cloned()

[22.550246]

[22.550312]

        Ok(self.open_channels.borrow().get(&name).cloned())

Replacement in libpijul/src/pristine/sanakirja.rs at line 690 [22.531056]

B:BD[22.550319] → [22.550319:550386]

    fn load_remote(&self, name: &str) -> Option<RemoteRef<Self>> {

[22.550319]

[22.550386]

    fn load_remote(&self, name: &str) -> Result<Option<RemoteRef<Self>>, TxnErr<Self::GraphError>> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 698 [22.531056]
B:BD[22.550721] → [22.550721:550741]
```
                ) {
```
[22.550721]
[22.550741]
```
                )? {
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 709 [22.531056]
B:BD[22.551128] → [22.551128:551161]
```
                    return None;
```
[22.551128]
[22.551161]
```
                    return Ok(None);
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 714 [22.531056]

B:BD[22.551240] → [50.431:486]

        self.open_remotes.borrow().get(&name).cloned()

[22.551240]

[22.551305]

        Ok(self.open_remotes.borrow().get(&name).cloned())

Replacement in libpijul/src/pristine/sanakirja.rs at line 733 [22.531056]

B:BD[22.551813] → [22.551813:551898]

    fn iter_channels<'txn>(&'txn self, start: &str) -> ChannelIterator<'txn, Self> {

[22.551813]

[22.551898]

    fn iter_channels<'txn>(
        &'txn self,
        start: &str,
    ) -> Result<ChannelIterator<'txn, Self>, TxnErr<Self::GraphError>> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 739 [22.531056]

B:BD[22.552019] → [22.552019:552125]

        ChannelIterator {
            cursor: self.txn.set_cursors(&self.channels, Some((name, None))).0,

[22.552019]

[22.552125]

        Ok(ChannelIterator {
            cursor: self.txn.set_cursors(&self.channels, Some((name, None)))?.0,

Replacement in libpijul/src/pristine/sanakirja.rs at line 742 [22.531056]
B:BD[22.552148] → [22.552148:552158]
```
        }
```
[22.552148]
[22.552158]
```
        })
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 760 [22.531056]

B:BD[22.552611] → [22.552611:552695]

    fn iter_remotes<'txn>(&'txn self, start: &str) -> RemotesIterator<'txn, Self> {

[22.552611]

[22.552695]

    fn iter_remotes<'txn>(
        &'txn self,
        start: &str,
    ) -> Result<RemotesIterator<'txn, Self>, TxnErr<Self::GraphError>> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 766 [22.531056]

B:BD[22.552816] → [22.552816:552921]

        RemotesIterator {
            cursor: self.txn.set_cursors(&self.remotes, Some((name, None))).0,

[22.552816]

[22.552921]

        Ok(RemotesIterator {
            cursor: self.txn.set_cursors(&self.remotes, Some((name, None)))?.0,

Replacement in libpijul/src/pristine/sanakirja.rs at line 769 [22.531056]
B:BD[22.552944] → [22.552944:552954]
```
        }
```
[22.552944]
[22.552954]
```
        })
```

Deletion in libpijul/src/pristine/sanakirja.rs at line 772 [22.531056]

B:BD[26.36950] → [49.2136:2256]

∅:D[49.2256] → [22.553148:553195]

B:BD[22.553148] → [22.553148:553195]

B:BD[22.553195] → [22.553195:553202]

B:BD[22.553202] → [41.709:738]

B:BD[41.738] → [8.445:571]

∅:D[8.571] → [41.880:940]

B:BD[41.880] → [41.880:940]

∅:D[41.940] → [52.115:115]

∅:D[52.115] → [49.2257:2292]

B:BD[22.553202] → [49.2257:2292]

∅:D[49.2292] → [22.553267:553288]

B:BD[22.553267] → [22.553267:553288]

B:BD[22.553288] → [49.2293:2368]

∅:D[49.2368] → [22.553368:553430]

B:BD[22.553368] → [22.553368:553430]

B:BD[22.553430] → [49.2369:2401]

∅:D[49.2401] → [22.553492:553513]

B:BD[22.553492] → [22.553492:553513]

B:BD[22.553513] → [49.2402:2477]

∅:D[49.2477] → [22.553593:553652]

B:BD[22.553593] → [22.553593:553652]

B:BD[22.553652] → [49.2478:2514]

∅:D[49.2514] → [22.553718:553749]

B:BD[22.553718] → [22.553718:553749]

B:BD[22.553749] → [49.2515:2610]

∅:D[49.2610] → [22.553853:553932]

B:BD[22.553853] → [22.553853:553932]

B:BD[22.553932] → [49.2611:2651]

∅:D[49.2651] → [22.554002:554023]

B:BD[22.554002] → [22.554002:554023]

B:BD[22.554023] → [49.2652:2749]

∅:D[49.2749] → [22.554125:554218]

B:BD[22.554125] → [22.554125:554218]

B:BD[22.554237] → [22.554237:554517]

    fn iter_inodes(
        &self,
    ) -> super::Cursor<Self, &Self, Self::InodesCursor, Inode, Position<ChangeId>> {
        self.cursor_inodes(&self.inodes, None)
    }
    #[cfg(debug_assertions)]
    fn iter_revinodes(
        &self,
    ) -> super::Cursor<Self, &Self, Self::RevinodesCursor, Position<ChangeId>, Inode> {
        self.cursor_revinodes(&self.revinodes, None)
    }
    fn iter_revdep(
        &self,
        k: ChangeId,
    ) -> super::Cursor<Self, &Self, Self::DepCursor, ChangeId, ChangeId> {
        self.cursor_dep(&self.revdep, Some((k, None)))
    }
    fn iter_dep(
        &self,
        k: ChangeId,
    ) -> super::Cursor<Self, &Self, Self::DepCursor, ChangeId, ChangeId> {
        self.cursor_dep(&self.dep, Some((k, None)))
    }
    fn iter_touched(
        &self,
        k: Position<ChangeId>,
    ) -> super::Cursor<Self, &Self, Self::Touched_filesCursor, Position<ChangeId>, ChangeId> {
        self.cursor_touched_files(&self.touched_files, Some((k, None)))
    }
    fn iter_rev_touched(
        &self,
        k: ChangeId,
    ) -> super::Cursor<Self, &Self, Self::Rev_touched_filesCursor, ChangeId, Position<ChangeId>>
    {
        self.cursor_rev_touched_files(&self.rev_touched_files, Some((k, None)))
    }
    fn iter_partials<'txn>(
        &'txn self,
        k: &str,
    ) -> super::Cursor<Self, &'txn Self, Self::PartialsCursor, SmallString, Position<ChangeId>>
    {
        let k0 = SmallString::from_str(k);
        self.cursor_partials(&self.partials, Some((k0, None)))
    }

Replacement in libpijul/src/pristine/sanakirja.rs at line 782 [22.531056]

B:BD[22.554839] → [22.554839:554923]

    ) -> super::Cursor<Self, &'txn Self, Self::RemoteCursor, u64, (Hash, Merkle)> {

[22.554839]

[22.554923]

    ) -> Result<
        super::Cursor<Self, &'txn Self, Self::RemoteCursor, u64, (Hash, Merkle)>,
        TxnErr<Self::GraphError>,
    > {

Replacement in libpijul/src/pristine/sanakirja.rs at line 793 [22.531056]

B:BD[22.555087] → [22.555087:555174]

    ) -> super::RevCursor<Self, &'txn Self, Self::RemoteCursor, u64, (Hash, Merkle)> {

[22.555087]

[22.555174]

    ) -> Result<
        super::RevCursor<Self, &'txn Self, Self::RemoteCursor, u64, (Hash, Merkle)>,
        TxnErr<Self::GraphError>,
    > {

Replacement in libpijul/src/pristine/sanakirja.rs at line 800 [22.531056]

B:BD[22.555242] → [22.555242:555312]

    fn get_remote(&mut self, name: &str) -> Option<RemoteRef<Self>> {

[22.555242]

[22.555312]

    fn get_remote(
        &mut self,
        name: &str,
    ) -> Result<Option<RemoteRef<Self>>, TxnErr<Self::GraphError>> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 811 [22.531056]
B:BD[22.555647] → [22.555647:555667]
```
                ) {
```
[22.555647]
[22.555667]
```
                )? {
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 822 [22.531056]
B:BD[22.556054] → [22.556054:556087]
```
                    return None;
```
[22.556054]
[22.556087]
```
                    return Ok(None);
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 827 [22.531056]

B:BD[22.556166] → [50.487:542]

        self.open_remotes.borrow().get(&name).cloned()

[22.556166]

[22.556231]

        Ok(self.open_remotes.borrow().get(&name).cloned())

Replacement in libpijul/src/pristine/sanakirja.rs at line 830 [22.531056]

B:BD[22.556238] → [22.556238:556369]

    fn last_remote(&self, remote: &Self::Remote) -> Option<(u64, (Hash, Merkle))> {
        self.txn.rev_iter(remote, None).next()

[22.556238]

[22.556369]

    fn last_remote(
        &self,
        remote: &Self::Remote,
    ) -> Result<Option<(u64, (Hash, Merkle))>, TxnErr<Self::GraphError>> {
        Ok(self.txn.rev_iter(remote, None)?.next().transpose()?)

Replacement in libpijul/src/pristine/sanakirja.rs at line 837 [22.531056]

B:BD[22.556376] → [22.556376:556533]

B:BD[22.556533] → [50.543:579]

    fn get_remote_state(&self, remote: &Self::Remote, n: u64) -> Option<(u64, (Hash, Merkle))> {
        self.txn
            .iter(remote, Some((n, None)))
            .find(|(k, _)| *k >= n)

[22.556376]

[22.556591]

    fn get_remote_state(
        &self,
        remote: &Self::Remote,
        n: u64,
    ) -> Result<Option<(u64, (Hash, Merkle))>, TxnErr<Self::GraphError>> {
        for x in self.txn.iter(remote, Some((n, None)))? {
            let (k, m) = x?;
            if k >= n {
                return Ok(Some((k, m)));
            }
        }
        Ok(None)

Replacement in libpijul/src/pristine/sanakirja.rs at line 851 [22.531056]

B:BD[22.556598] → [22.556598:556746]

    fn remote_has_change(&self, remote: &RemoteRef<Self>, hash: Hash) -> bool {
        self.txn.get(&remote.db.borrow().rev, hash, None).is_some()

[22.556598]

[22.556746]

    fn remote_has_change(
        &self,
        remote: &RemoteRef<Self>,
        hash: Hash,
    ) -> Result<bool, TxnErr<Self::GraphError>> {
        Ok(self.txn.get(&remote.db.borrow().rev, hash, None)?.is_some())

Replacement in libpijul/src/pristine/sanakirja.rs at line 858 [22.531056]

B:BD[22.556752] → [22.556752:556898]

    fn remote_has_state(&self, remote: &RemoteRef<Self>, m: Merkle) -> bool {
        self.txn.get(&remote.db.borrow().states, m, None).is_some()

[22.556752]

[22.556898]

    fn remote_has_state(
        &self,
        remote: &RemoteRef<Self>,
        m: Merkle,
    ) -> Result<bool, TxnErr<Self::GraphError>> {
        Ok(self.txn.get(&remote.db.borrow().states, m, None)?.is_some())

Replacement in libpijul/src/pristine/sanakirja.rs at line 865 [22.531056]

B:BD[22.556904] → [22.556904:557051]

B:BD[22.557051] → [22.557051:557057]

B:BD[22.557057] → [22.557057:557915]

B:BD[22.557915] → [22.557915:557921]

B:BD[22.557921] → [22.557921:558202]

    fn channel_has_state(&self, channel: &ChannelRef<Self>, m: Merkle) -> bool {
        self.txn.get(&channel.borrow().states, m, None).is_some()
    }
}
/*
impl<T> MutTxn<T> {
    pub fn with_remote_mut<F: FnMut(&mut Db<u64, (Hash, Merkle)>)>(
        &mut self,
        name: &str,
        mut f: F,
    ) -> Result<bool, anyhow::Error> {
        let name = SmallString::from_str(name);
        let name = UnsafeSmallStr::from_small_str(name.as_small_str());
        if let Some((mut db0, db1, db2)) = self.txn.get(&self.remotes, name, None) {
            f(&mut db0);
            let mut db: ::sanakirja::Db<UnsafeSmallStr, (u64, u64, u64)> =
                unsafe { std::mem::transmute(self.remotes) };
            self.txn.del(&mut self.rng, &mut db, name, None)?;
            self.remotes = unsafe { std::mem::transmute(db) };
            self.txn
                .put(&mut self.rng, &mut self.remotes, name, (db0, db1, db2))?;
            Ok(true)
        } else {
            Ok(false)
        }
    }
    pub fn del_remote(&mut self, name: &str) -> Result<(), anyhow::Error> {
        let name = SmallString::from_str(name);
        let name = UnsafeSmallStr::from_small_str(name.as_small_str());
        self.txn.del(&mut self.rng, &mut self.remotes, name, None)?;
        Ok(())

[22.556904]

[22.558202]

    fn channel_has_state(
        &self,
        channel: &ChannelRef<Self>,
        m: Merkle,
    ) -> Result<bool, TxnErr<Self::GraphError>> {
        Ok(self.txn.get(&channel.borrow().states, m, None)?.is_some())

Deletion in libpijul/src/pristine/sanakirja.rs at line 873 [22.531056]

B:BD[22.558210] → [22.558210:558214]

B:BD[22.558214] → [22.558214:558872]

 */
impl MutTxnT for MutTxn<()> {
    sanakirja_put_del!(internal, Hash, ChangeId);
    sanakirja_put_del!(external, ChangeId, Hash);
    sanakirja_put_del!(inodes, Inode, Position<ChangeId>);
    sanakirja_put_del!(revinodes, Position<ChangeId>, Inode);
    sanakirja_put_del!(tree, PathId, Inode, UnsafePathId::from_fileid(k), v);
    sanakirja_put_del!(revtree, Inode, PathId, k, UnsafePathId::from_fileid(v),);
    sanakirja_put_del!(dep, ChangeId, ChangeId);
    sanakirja_put_del!(revdep, ChangeId, ChangeId);
    sanakirja_put_del!(touched_files, Position<ChangeId>, ChangeId);
    sanakirja_put_del!(rev_touched_files, ChangeId, Position<ChangeId>);

Insertion in libpijul/src/pristine/sanakirja.rs at line 874 [22.531056]
[22.558873]
[22.558892]
```
impl GraphMutTxnT for MutTxn<()> {
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 880 [22.531056]
B:BD[22.559008] → [23.14284:14321]
```
    ) -> Result<bool, Self::Error> {
```
[22.559008]
[22.559047]
```
    ) -> Result<bool, TxnErr<Self::GraphError>> {
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 889 [22.531056]
B:BD[22.559250] → [23.14322:14359]
```
    ) -> Result<bool, Self::Error> {
```
[22.559250]
[22.559289]
```
    ) -> Result<bool, TxnErr<Self::GraphError>> {
```

Insertion in libpijul/src/pristine/sanakirja.rs at line 893 [22.531056]

[22.559394]

    sanakirja_put_del!(internal, Hash, ChangeId, GraphError);
    sanakirja_put_del!(external, ChangeId, Hash, GraphError);
}

Replacement in libpijul/src/pristine/sanakirja.rs at line 897 [22.531056]

B:BD[22.559395] → [23.14360:14454]

∅:D[23.14454] → [22.559510:559731]

B:BD[22.559510] → [22.559510:559731]

B:BD[22.559731] → [26.36953:36954]

∅:D[26.36954] → [22.559750:559846]

B:BD[22.559750] → [22.559750:559846]

B:BD[22.559846] → [23.14455:14492]

∅:D[23.14492] → [22.559885:560107]

B:BD[22.559885] → [22.559885:560107]

    fn put_partials(&mut self, k: &str, e: Position<ChangeId>) -> Result<bool, Self::Error> {
        let k = SmallString::from_str(k);
        Ok(self.txn.put(
            &mut self.rng,
            &mut self.partials,
            UnsafeSmallStr::from_small_str(k.as_small_str()),
            e,
        )?)
    }
    fn del_partials(
        &mut self,
        k: &str,
        e: Option<Position<ChangeId>>,
    ) -> Result<bool, Self::Error> {
        let k = SmallString::from_str(k);
        Ok(self.txn.del(
            &mut self.rng,
            &mut self.partials,
            UnsafeSmallStr::from_small_str(k.as_small_str()),
            e,
        )?)
    }

[22.559395]

[22.560126]

impl ChannelMutTxnT for MutTxn<()> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 904 [22.531056]

B:BD[22.560268] → [23.14493:14540]

∅:D[23.14540] → [22.560317:560386]

B:BD[22.560317] → [22.560317:560386]

    ) -> Result<Option<Merkle>, Self::Error> {
        if self.get_changeset(&channel.changes, p, None).is_none() {

[22.560268]

[22.560386]

    ) -> Result<Option<Merkle>, TxnErr<Self::GraphError>> {
        if self.get_changeset(&channel.changes, p, None)?.is_none() {

Replacement in libpijul/src/pristine/sanakirja.rs at line 908 [22.531056]

B:BD[22.560477] → [22.560477:560596]

            let m = if let Some((_, (_, m))) = self.txn.rev_iter(&channel.revchanges, None).next() {
                m

[22.560477]

[22.560596]

            let m = if let Some(x) = self.txn.rev_iter(&channel.revchanges, None)?.next() {
                (x?.1).1

Replacement in libpijul/src/pristine/sanakirja.rs at line 915 [22.531056]

B:BD[22.560719] → [22.560719:560783]

                .get_revchangeset(&channel.revchanges, t, None)

[22.560719]

[22.560783]

                .get_revchangeset(&channel.revchanges, t, None)?

Replacement in libpijul/src/pristine/sanakirja.rs at line 932 [22.531056]
B:BD[22.561234] → [23.14541:14578]
```
    ) -> Result<bool, Self::Error> {
```
[22.561234]
[22.561273]
```
    ) -> Result<bool, TxnErr<Self::GraphError>> {
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 934 [22.531056]

B:BD[22.561308] → [22.561308:561390]

        for (t_, (p, _)) in self.txn.iter(&channel.revchanges, Some((t, None))) {

[22.561308]

[22.561390]

        for x in self.txn.iter(&channel.revchanges, Some((t, None)))? {
            let (t_, (p, _)) = x?;

Replacement in libpijul/src/pristine/sanakirja.rs at line 941 [22.531056]

B:BD[22.561510] → [22.561510:561597]

        for (t_, (_, m_)) in self.txn.rev_iter(&channel.revchanges, Some((t, None))) {

[22.561510]

[22.561597]

        for x in self.txn.rev_iter(&channel.revchanges, Some((t, None)))? {
            let (t_, (_, m_)) = x?;

Replacement in libpijul/src/pristine/sanakirja.rs at line 953 [22.531056]

B:BD[22.561901] → [22.561901:561962]

                m = m.next(&self.get_external(*p).unwrap());

[22.561901]

[22.561962]

                m = m.next(&self.get_external(*p)?.unwrap());

Insertion in libpijul/src/pristine/sanakirja.rs at line 961 [22.531056]

[22.562193]

    }
}
impl DepsMutTxnT for MutTxn<()> {
    sanakirja_put_del!(dep, ChangeId, ChangeId, DepsError);
    sanakirja_put_del!(revdep, ChangeId, ChangeId, DepsError);
    sanakirja_put_del!(touched_files, Position<ChangeId>, ChangeId, DepsError);
    sanakirja_put_del!(rev_touched_files, ChangeId, Position<ChangeId>, DepsError);
}
impl TreeMutTxnT for MutTxn<()> {
    sanakirja_put_del!(inodes, Inode, Position<ChangeId>, TreeError);
    sanakirja_put_del!(revinodes, Position<ChangeId>, Inode, TreeError);
    sanakirja_put_del!(
        tree,
        PathId,
        Inode,
        TreeError,
        UnsafePathId::from_fileid(k),
        v
    );
    sanakirja_put_del!(
        revtree,
        Inode,
        PathId,
        TreeError,
        k,
        UnsafePathId::from_fileid(v)
    );
    fn put_partials(
        &mut self,
        k: &str,
        e: Position<ChangeId>,
    ) -> Result<bool, TxnErr<Self::TreeError>> {
        let k = SmallString::from_str(k);
        Ok(self.txn.put(
            &mut self.rng,
            &mut self.partials,
            UnsafeSmallStr::from_small_str(k.as_small_str()),
            e,
        )?)

Insertion in libpijul/src/pristine/sanakirja.rs at line 1006 [22.531056]

[22.562200]

    fn del_partials(
        &mut self,
        k: &str,
        e: Option<Position<ChangeId>>,
    ) -> Result<bool, TxnErr<Self::TreeError>> {
        let k = SmallString::from_str(k);
        Ok(self.txn.del(
            &mut self.rng,
            &mut self.partials,
            UnsafeSmallStr::from_small_str(k.as_small_str()),
            e,
        )?)
    }
}
impl MutTxnT for MutTxn<()> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1027 [22.531056]
B:BD[22.562319] → [23.14579:14616]
```
    ) -> Result<bool, Self::Error> {
```
[22.562319]
[22.562358]
```
    ) -> Result<bool, Self::GraphError> {
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1034 [22.531056]

B:BD[22.562607] → [23.14617:14715]

    fn del_remote(&mut self, remote: &mut RemoteRef<Self>, k: u64) -> Result<bool, Self::Error> {

[22.562607]

[22.562707]

    fn del_remote(
        &mut self,
        remote: &mut RemoteRef<Self>,
        k: u64,
    ) -> Result<bool, Self::GraphError> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1040 [22.531056]

B:BD[22.562753] → [22.562753:562823]

        if let Some((h, m)) = self.txn.get(&remote.remote, k, None) {

[22.562753]

[22.562823]

        if let Some((h, m)) = self.txn.get(&remote.remote, k, None)? {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1049 [22.531056]

B:BD[22.563092] → [23.14716:14812]

    fn open_or_create_channel(&mut self, name: &str) -> Result<ChannelRef<Self>, Self::Error> {

[22.563092]

[22.563190]

    fn open_or_create_channel(&mut self, name: &str) -> Result<ChannelRef<Self>, Self::GraphError> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1065 [22.531056]
B:BD[22.563779] → [22.563779:563799]
```
                ) {
```
[22.563779]
[22.563799]
```
                )? {
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1106 [22.531056]

B:BD[22.565222] → [23.14813:14873]

    ) -> Result<ChannelRef<Self>, ForkError<Self::Error>> {

[22.565222]

[22.565273]

    ) -> Result<ChannelRef<Self>, ForkError<Self::GraphError>> {

Insertion in libpijul/src/pristine/sanakirja.rs at line 1116 [22.531056]
[22.565555]
[22.565555]
```
            .map_err(|e| ForkError::Txn(e.into()))?
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 1153 [22.531056]
B:BD[22.566578] → [23.15715:15761]
```
    ) -> Result<(), ForkError<Self::Error>> {
```
[22.566578]
[22.566615]
```
    ) -> Result<(), ForkError<Self::GraphError>> {
```
Insertion in libpijul/src/pristine/sanakirja.rs at line 1162 [22.531056]
[22.566855]
[22.566855]
```
            .map_err(|e| ForkError::Txn(e.into()))?
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1193 [22.531056]

B:BD[22.567504] → [23.16141:16215]

    fn drop_channel(&mut self, name: &str) -> Result<bool, Self::Error> {

[22.567504]

[22.567580]

    fn drop_channel(&mut self, name: &str) -> Result<bool, Self::GraphError> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1207 [22.531056]

B:BD[22.567999] → [23.16216:16310]

    fn open_or_create_remote(&mut self, name: &str) -> Result<RemoteRef<Self>, Self::Error> {

[22.567999]

[22.568095]

    fn open_or_create_remote(&mut self, name: &str) -> Result<RemoteRef<Self>, Self::GraphError> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1216 [22.531056]
B:BD[22.568483] → [22.568483:568503]
```
                ) {
```
[22.568483]
[22.568503]
```
                )? {
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1247 [22.531056]

B:BD[22.569566] → [23.16311:16397]

    fn drop_remote(&mut self, remote: RemoteRef<Self>) -> Result<bool, Self::Error> {

[22.569566]

[22.569654]

    fn drop_remote(&mut self, remote: RemoteRef<Self>) -> Result<bool, Self::GraphError> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1260 [22.531056]

B:BD[22.570030] → [23.16398:16477]

    fn drop_named_remote(&mut self, name: &str) -> Result<bool, Self::Error> {

[22.570030]

[22.570111]

    fn drop_named_remote(&mut self, name: &str) -> Result<bool, Self::GraphError> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1273 [22.531056]
B:BD[22.570478] → [23.16478:16531]
```
    fn commit(mut self) -> Result<(), Self::Error> {
```
[22.570478]
[22.570533]
```
    fn commit(mut self) -> Result<(), Self::GraphError> {
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1312 [22.531056]

B:BD[22.572085] → [22.572085:572161]

    pub fn load_const_channel(&self, name: &str) -> Option<Channel<Self>> {

[22.572085]

[22.572161]

    pub fn load_const_channel(&self, name: &str) -> Result<Option<Channel<Self>>, SanakirjaError> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1318 [22.531056]
B:BD[22.572420] → [22.572420:572459]
```
        ) {
            Some(Channel {
```
[22.572420]
[22.572459]
```
        )? {
            Ok(Some(Channel {
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 1327 [22.531056]
B:BD[22.572696] → [22.572696:572711]
```
            })
```
[22.572696]
[22.572711]
```
            }))
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 1329 [22.531056]
B:BD[22.572728] → [22.572728:572745]
```
            None
```
[22.572728]
[22.572745]
```
            Ok(None)
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1386 [22.531056]

B:BD[22.574894] → [23.16715:16806]

    fn put_remotes(&mut self, remote: RemoteRef<Self>) -> Result<(), ::sanakirja::Error> {

[22.574894]

[22.574980]

    fn put_remotes(&mut self, remote: RemoteRef<Self>) -> Result<(), SanakirjaError> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1410 [22.531056]

B:BD[22.575835] → [23.16807:16900]

    fn commit_remote(&mut self, remote: RemoteRef<Self>) -> Result<(), ::sanakirja::Error> {

[22.575835]

[22.575923]

    fn commit_remote(&mut self, remote: RemoteRef<Self>) -> Result<(), SanakirjaError> {

Replacement in libpijul/src/pristine/mod.rs at line 40 [22.586748]
B:BD[22.587546] → [22.587546:587576]
```
pub struct Channel<T: TxnT> {
```
[22.587546]
[22.587576]
```
pub struct Channel<T: ChannelTxnT> {
```
Replacement in libpijul/src/pristine/mod.rs at line 50 [22.586748]
B:BD[22.587807] → [22.587807:587840]
```
pub struct ChannelRef<T: TxnT> {
```
[22.587807]
[22.587840]
```
pub struct ChannelRef<T: ChannelTxnT> {
```
Replacement in libpijul/src/pristine/mod.rs at line 54 [22.586748]
B:BD[22.587886] → [22.587886:587926]
```
impl<T: TxnT> Clone for ChannelRef<T> {
```
[22.587886]
[22.587926]
```
impl<T: ChannelTxnT> Clone for ChannelRef<T> {
```
Replacement in libpijul/src/pristine/mod.rs at line 60 [22.586748]
B:BD[22.588006] → [22.588006:588033]
```
impl<T: TxnT> Channel<T> {
```
[22.588006]
[22.588033]
```
impl<T: ChannelTxnT> Channel<T> {
```
Replacement in libpijul/src/pristine/mod.rs at line 66 [22.586748]
B:BD[21.6577] → [21.6577:6607]
```
impl<T: MutTxnT> Channel<T> {
```
[21.6577]
[21.6607]
```
impl<T: ChannelTxnT> Channel<T> {
```
Replacement in libpijul/src/pristine/mod.rs at line 81 [22.586748]
B:BD[22.588200] → [22.588200:588230]
```
impl<T: TxnT> ChannelRef<T> {
```
[22.588200]
[22.588230]
```
impl<T: ChannelTxnT> ChannelRef<T> {
```
Replacement in libpijul/src/pristine/mod.rs at line 120 [22.586748]
B:BD[23.16925] → [23.16925:16952]
```
pub enum HashPrefixError {
```
[23.16925]
[23.16952]
```
pub enum HashPrefixError<T: std::error::Error + 'static> {
```
Insertion in libpijul/src/pristine/mod.rs at line 127 [22.586748]
[23.17146]
[23.17146]
```
    #[error(transparent)]
    Txn(T),
```

Replacement in libpijul/src/pristine/mod.rs at line 139 [22.586748]

∅:D[23.17347] → [22.589140:589205]

B:BD[22.589140] → [22.589140:589205]

B:BD[22.589205] → [23.17348:17407]

/// The trait of immutable transactions.
pub trait TxnT: Sized {
    type Error: std::error::Error + Send + Sync + 'static;

[23.17347]

[22.589205]

#[derive(Debug, Error)]
#[error(transparent)]
pub struct TxnErr<E: std::error::Error + 'static>(pub E);
pub trait GraphTxnT: Sized {
    type GraphError: std::error::Error + Send + Sync + 'static;

Replacement in libpijul/src/pristine/mod.rs at line 146 [22.586748]

B:BD[22.589224] → [22.589224:589313]

    cursor_ref!(graph, Vertex<ChangeId>, Edge);
    get!(graph, Vertex<ChangeId>, Edge);

[22.589224]

[22.589313]

    cursor_ref!(graph, Vertex<ChangeId>, Edge, GraphError);
    get!(graph, Vertex<ChangeId>, Edge, GraphError);
    /// Returns the external hash of an internal change identifier, if
    /// the change is known.
    fn get_external(&self, p: ChangeId) -> Result<Option<Hash>, TxnErr<Self::GraphError>>;
    /// Returns the internal change identifier of change with external
    /// hash `hash`, if the change is known.
    fn get_internal(&self, p: Hash) -> Result<Option<ChangeId>, TxnErr<Self::GraphError>>;
}

Insertion in libpijul/src/pristine/mod.rs at line 157 [22.586748]
[22.589314]
[22.589314]
```
pub trait ChannelTxnT: GraphTxnT {
```

Replacement in libpijul/src/pristine/mod.rs at line 159 [22.586748]

B:BD[22.589337] → [22.589337:589412]

    get!(changeset, ChangeId, u64);
    cursor!(changeset, ChangeId, u64);

[22.589337]

[22.589412]

    get!(changeset, ChangeId, u64, GraphError);
    cursor!(changeset, ChangeId, u64, GraphError);

Replacement in libpijul/src/pristine/mod.rs at line 163 [22.586748]

B:BD[22.589439] → [22.589439:589600]

    get!(revchangeset, u64, (ChangeId, Merkle));
    cursor_ref!(revchangeset, u64, (ChangeId, Merkle));
    rev_cursor!(revchangeset, u64, (ChangeId, Merkle));

[22.589439]

[22.589600]

    get!(revchangeset, u64, (ChangeId, Merkle), GraphError);
    cursor_ref!(revchangeset, u64, (ChangeId, Merkle), GraphError);
    rev_cursor!(revchangeset, u64, (ChangeId, Merkle), GraphError);

Insertion in libpijul/src/pristine/mod.rs at line 168 [22.586748]

[22.589628]

}
pub trait DepsTxnT: Sized {
    type DepsError: std::error::Error + Send + Sync + 'static;
    table!(revdep);
    table!(dep);
    table_get!(dep, ChangeId, ChangeId, DepsError);
    cursor_ref!(dep, ChangeId, ChangeId, DepsError);
    table_get!(revdep, ChangeId, ChangeId, DepsError);
    fn iter_revdep(
        &self,
        p: ChangeId,
    ) -> Result<Cursor<Self, &Self, Self::DepCursor, ChangeId, ChangeId>, TxnErr<Self::DepsError>>;
    fn iter_dep(
        &self,
        p: ChangeId,
    ) -> Result<Cursor<Self, &Self, Self::DepCursor, ChangeId, ChangeId>, TxnErr<Self::DepsError>>;
    fn iter_dep_ref<RT: std::ops::Deref<Target = Self> + Clone>(
        txn: RT,
        p: ChangeId,
    ) -> Result<Cursor<Self, RT, Self::DepCursor, ChangeId, ChangeId>, TxnErr<Self::DepsError>>;
    fn iter_touched(
        &self,
        p: Position<ChangeId>,
    ) -> Result<
        Cursor<Self, &Self, Self::Touched_filesCursor, Position<ChangeId>, ChangeId>,
        TxnErr<Self::DepsError>,
    >;
    fn iter_rev_touched(
        &self,
        p: ChangeId,
    ) -> Result<
        Cursor<Self, &Self, Self::Rev_touched_filesCursor, ChangeId, Position<ChangeId>>,
        TxnErr<Self::DepsError>,
    >;
    table!(touched_files);
    table!(rev_touched_files);
    table_get!(touched_files, Position<ChangeId>, ChangeId, DepsError);
    table_get!(rev_touched_files, ChangeId, Position<ChangeId>, DepsError);
    iter!(touched_files, Position<ChangeId>, ChangeId, DepsError);
    iter!(rev_touched_files, ChangeId, Position<ChangeId>, DepsError);
}

Insertion in libpijul/src/pristine/mod.rs at line 211 [22.586748]

[22.589629]

pub trait TreeTxnT: Sized {
    type TreeError: std::error::Error + Send + Sync + 'static;

Replacement in libpijul/src/pristine/mod.rs at line 214 [22.586748]

B:BD[22.589647] → [22.589647:589721]

    table_get!(tree, PathId, Inode);
    iter!(tree, OwnedPathId, Inode);

[22.589647]

[22.589721]

    table_get!(tree, PathId, Inode, TreeError);
    iter!(tree, OwnedPathId, Inode, TreeError);

Replacement in libpijul/src/pristine/mod.rs at line 218 [22.586748]

B:BD[22.589743] → [22.589743:589823]

    table_get!(revtree, Inode, PathId);
    iter!(revtree, Inode, OwnedPathId);

[22.589743]

[22.589823]

    table_get!(revtree, Inode, PathId, TreeError);
    iter!(revtree, Inode, OwnedPathId, TreeError);

Replacement in libpijul/src/pristine/mod.rs at line 223 [22.586748]

∅:D[41.964] → [22.589844:589949]

B:BD[22.589844] → [22.589844:589949]

    table_get!(inodes, Inode, Position<ChangeId>);
    table_get!(revinodes, Position<ChangeId>, Inode);

[41.964]

[22.589949]

    table_get!(inodes, Inode, Position<ChangeId>, TreeError);
    table_get!(revinodes, Position<ChangeId>, Inode, TreeError);

Replacement in libpijul/src/pristine/mod.rs at line 227 [22.586748]

B:BD[22.589972] → [22.589972:590028]

    cursor!(partials, SmallString, Position<ChangeId>);

[22.589972]

[22.590028]

    cursor!(partials, SmallString, Position<ChangeId>, TreeError);
    cursor!(inodes, Inode, Position<ChangeId>, TreeError);
    fn iter_inodes(
        &self,
    ) -> Result<
        Cursor<Self, &Self, Self::InodesCursor, Inode, Position<ChangeId>>,
        TxnErr<Self::TreeError>,
    >;

Replacement in libpijul/src/pristine/mod.rs at line 236 [22.586748]

B:BD[22.590029] → [22.590029:590120]

    table!(channels);
    cursor!(channels, SmallString, (u64, u64, u64, u64, u64, u64));

[22.590029]

[22.590139]

    #[cfg(debug_assertions)]
    cursor!(revinodes, Position<ChangeId>, Inode, TreeError);
    #[cfg(debug_assertions)]
    fn iter_revinodes(
        &self,
    ) -> Result<
        Cursor<Self, &Self, Self::RevinodesCursor, Position<ChangeId>, Inode>,
        TxnErr<Self::TreeError>,
    >;

Replacement in libpijul/src/pristine/mod.rs at line 248 [22.586748]

B:BD[22.590210] → [22.590210:590300]

    ) -> Cursor<Self, &'txn Self, Self::PartialsCursor, SmallString, Position<ChangeId>>;

[22.590210]

[22.590300]

    ) -> Result<
        Cursor<Self, &'txn Self, Self::PartialsCursor, SmallString, Position<ChangeId>>,
        TxnErr<Self::TreeError>,
    >;
}

Replacement in libpijul/src/pristine/mod.rs at line 254 [22.586748]

B:BD[22.590301] → [22.590301:590867]

B:BD[22.590886] → [22.590886:591060]

B:BD[22.591079] → [22.591079:591136]

    table!(revdep);
    table!(dep);
    table_get!(dep, ChangeId, ChangeId);
    cursor_ref!(dep, ChangeId, ChangeId);
    table_get!(revdep, ChangeId, ChangeId);
    table!(touched_files);
    table!(rev_touched_files);
    table_get!(touched_files, Position<ChangeId>, ChangeId);
    table_get!(rev_touched_files, ChangeId, Position<ChangeId>);
    iter!(touched_files, Position<ChangeId>, ChangeId);
    iter!(rev_touched_files, ChangeId, Position<ChangeId>);
    /// Returns the external hash of an internal change identifier, if
    /// the change is known.
    fn get_external(&self, p: ChangeId) -> Option<Hash>;
    /// Returns the internal change identifier of change with external
    /// hash `hash`, if the change is known.
    fn get_internal(&self, p: Hash) -> Option<ChangeId>;

[22.590301]

[22.591136]

/// The trait of immutable transactions.
pub trait TxnT:
    GraphTxnT
    + ChannelTxnT
    + DepsTxnT<DepsError = <Self as GraphTxnT>::GraphError>
    + TreeTxnT<TreeError = <Self as GraphTxnT>::GraphError>
{
    table!(channels);
    cursor!(channels, SmallString, (u64, u64, u64, u64, u64, u64));

Replacement in libpijul/src/pristine/mod.rs at line 264 [22.586748]

B:BD[22.591137] → [23.17408:17499]

    fn hash_from_prefix(&self, prefix: &str) -> Result<(Hash, ChangeId), HashPrefixError>;

[22.591137]

[22.591226]

    fn hash_from_prefix(
        &self,
        prefix: &str,
    ) -> Result<(Hash, ChangeId), HashPrefixError<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 272 [22.586748]
B:BD[22.591329] → [23.17500:17540]
```
    ) -> Result<Hash, HashPrefixError>;
```
[22.591329]
[22.591367]
```
    ) -> Result<Hash, HashPrefixError<Self::GraphError>>;
```

Replacement in libpijul/src/pristine/mod.rs at line 284 [22.586748]

B:BD[22.591984] → [22.591984:592052]

    fn load_channel(&self, name: &str) -> Option<ChannelRef<Self>>;

[22.591984]

[22.592052]

    fn load_channel(
        &self,
        name: &str,
    ) -> Result<Option<ChannelRef<Self>>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 289 [22.586748]

B:BD[22.592053] → [22.592053:592119]

    fn load_remote(&self, name: &str) -> Option<RemoteRef<Self>>;

[22.592053]

[22.592119]

    fn load_remote(&self, name: &str) -> Result<Option<RemoteRef<Self>>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 293 [22.586748]

B:BD[22.592225] → [22.592225:592310]

B:BD[22.592329] → [22.592329:592412]

B:BD[22.599224] → [22.599224:599225]

B:BD[22.599225] → [8.572:672]

∅:D[8.672] → [22.600030:600031]

B:BD[22.600030] → [22.600030:600031]

B:BD[22.600031] → [8.673:770]

∅:D[8.770] → [22.600186:600187]

B:BD[22.600186] → [22.600186:600187]

B:BD[22.600206] → [22.600206:600373]

    fn iter_channels<'txn>(&'txn self, start: &str) -> ChannelIterator<'txn, Self>;
    fn iter_remotes<'txn>(&'txn self, start: &str) -> RemotesIterator<'txn, Self>;
    fn iter_revdep(&self, p: ChangeId) -> Cursor<Self, &Self, Self::DepCursor, ChangeId, ChangeId>;
    fn iter_dep(&self, p: ChangeId) -> Cursor<Self, &Self, Self::DepCursor, ChangeId, ChangeId>;
    fn iter_dep_ref<RT: std::ops::Deref<Target = Self> + Clone>(
        txn: RT,
        p: ChangeId,
    ) -> Cursor<Self, RT, Self::DepCursor, ChangeId, ChangeId>;

[22.592225]

[22.600373]

    fn iter_channels<'txn>(
        &'txn self,
        start: &str,
    ) -> Result<ChannelIterator<'txn, Self>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 298 [22.586748]

B:BD[22.600374] → [8.771:807]

∅:D[8.807] → [22.600440:600471]

B:BD[22.600440] → [22.600440:600471]

B:BD[22.600471] → [8.808:895]

    fn iter_touched(
        &self,
        p: Position<ChangeId>,
    ) -> Cursor<Self, &Self, Self::Touched_filesCursor, Position<ChangeId>, ChangeId>;

[22.600374]

[22.600563]

    fn iter_remotes<'txn>(
        &'txn self,
        start: &str,
    ) -> Result<RemotesIterator<'txn, Self>, TxnErr<Self::GraphError>>;

Deletion in libpijul/src/pristine/mod.rs at line 303 [22.586748]
B:BD[22.600564] → [8.896:936]
∅:D[8.936] → [22.600634:600655]
B:BD[22.600634] → [22.600634:600655]
B:BD[22.600655] → [8.937:1028]
∅:D[8.1028] → [22.605607:605608]
B:BD[22.605607] → [22.605607:605608]
```
    fn iter_rev_touched(
        &self,
        p: ChangeId,
    ) -> Cursor<Self, &Self, Self::Rev_touched_filesCursor, ChangeId, Position<ChangeId>>;
```

Replacement in libpijul/src/pristine/mod.rs at line 315 [22.586748]

B:BD[22.606010] → [22.606010:606086]

    ) -> Cursor<Self, &'txn Self, Self::RemoteCursor, u64, (Hash, Merkle)>;

[22.606010]

[22.606086]

    ) -> Result<
        Cursor<Self, &'txn Self, Self::RemoteCursor, u64, (Hash, Merkle)>,
        TxnErr<Self::GraphError>,
    >;

Replacement in libpijul/src/pristine/mod.rs at line 324 [22.586748]

B:BD[22.606192] → [22.606192:606425]

    ) -> RevCursor<Self, &'txn Self, Self::RemoteCursor, u64, (Hash, Merkle)>;
    fn get_remote(&mut self, name: &str) -> Option<RemoteRef<Self>>;
    fn last_remote(&self, remote: &Self::Remote) -> Option<(u64, (Hash, Merkle))>;

[22.606192]

[22.606425]

    ) -> Result<
        RevCursor<Self, &'txn Self, Self::RemoteCursor, u64, (Hash, Merkle)>,
        TxnErr<Self::GraphError>,
    >;

Replacement in libpijul/src/pristine/mod.rs at line 329 [22.586748]

B:BD[22.606426] → [22.606426:606522]

    fn get_remote_state(&self, remote: &Self::Remote, n: u64) -> Option<(u64, (Hash, Merkle))>;

[22.606426]

[22.606522]

    fn get_remote(
        &mut self,
        name: &str,
    ) -> Result<Option<RemoteRef<Self>>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 334 [22.586748]

B:BD[22.606523] → [22.606523:606765]

    fn remote_has_change(&self, remote: &RemoteRef<Self>, hash: Hash) -> bool;
    fn remote_has_state(&self, remote: &RemoteRef<Self>, hash: Merkle) -> bool;
    fn channel_has_state(&self, channel: &ChannelRef<Self>, hash: Merkle) -> bool;

[22.606523]

[26.36993]

    fn last_remote(
        &self,
        remote: &Self::Remote,
    ) -> Result<Option<(u64, (Hash, Merkle))>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 339 [22.586748]

B:BD[26.37026] → [26.37026:37074]

B:BD[26.37074] → [8.1029:1126]

    cursor!(inodes, Inode, Position<ChangeId>);
    fn iter_inodes(&self) -> Cursor<Self, &Self, Self::InodesCursor, Inode, Position<ChangeId>>;

[26.36994]

[41.965]

    fn get_remote_state(
        &self,
        remote: &Self::Remote,
        n: u64,
    ) -> Result<Option<(u64, (Hash, Merkle))>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 345 [22.586748]

B:BD[41.966] → [41.966:1075]

B:BD[41.1075] → [8.1127:1150]

    #[cfg(debug_assertions)]
    cursor!(revinodes, Position<ChangeId>, Inode);
    #[cfg(debug_assertions)]
    fn iter_revinodes(

[41.966]

[8.1150]

    fn remote_has_change(
        &self,
        remote: &RemoteRef<Self>,
        hash: Hash,
    ) -> Result<bool, TxnErr<Self::GraphError>>;
    fn remote_has_state(

Replacement in libpijul/src/pristine/mod.rs at line 352 [22.586748]

B:BD[8.1165] → [8.1165:1245]

    ) -> Cursor<Self, &Self, Self::RevinodesCursor, Position<ChangeId>, Inode>;

[8.1165]

[26.37267]

        remote: &RemoteRef<Self>,
        hash: Merkle,
    ) -> Result<bool, TxnErr<Self::GraphError>>;
    fn channel_has_state(
        &self,
        channel: &ChannelRef<Self>,
        hash: Merkle,
    ) -> Result<bool, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 364 [22.586748]
B:BD[26.37377] → [26.37377:37431]
```
pub(crate) fn iter_adjacent<'db, 'txn: 'db, T: TxnT>(
```
[26.37377]
[26.37431]
```
pub(crate) fn iter_adjacent<'db, 'txn: 'db, T: GraphTxnT>(
```
Replacement in libpijul/src/pristine/mod.rs at line 366 [22.586748]
B:BD[26.37449] → [26.37449:37479]
```
    channel: &'db Channel<T>,
```
[26.37449]
[26.37479]
```
    graph: &'db T::Graph,
```
Replacement in libpijul/src/pristine/mod.rs at line 370 [22.586748]
B:BD[26.37556] → [26.37556:37589]
```
) -> AdjacentIterator<'txn, T> {
```
[26.37556]
[26.37589]
```
) -> Result<AdjacentIterator<'txn, T>, TxnErr<T::GraphError>> {
```

Replacement in libpijul/src/pristine/mod.rs at line 376 [22.586748]

B:BD[26.37711] → [26.37711:37796]

    AdjacentIterator {
        it: iter_graph(txn, &channel.graph, key, Some(edge)),

[26.37711]

[26.37796]

    Ok(AdjacentIterator {
        it: iter_graph(txn, graph, key, Some(edge))?,

Replacement in libpijul/src/pristine/mod.rs at line 381 [22.586748]
∅:D[26.37845] → [22.607389:607395]
B:BD[22.607389] → [22.607389:607395]
```
    }
```
[26.37845]
[21.6832]
```
    })
```

Replacement in libpijul/src/pristine/mod.rs at line 384 [22.586748]

B:BD[21.6835] → [21.6835:6895]

pub(crate) fn iter_alive_children<'db, 'txn: 'db, T: TxnT>(

[21.6835]

[21.6895]

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

Replacement in libpijul/src/pristine/mod.rs at line 386 [22.586748]
B:BD[21.6913] → [21.6913:6943]
```
    channel: &'db Channel<T>,
```
[21.6913]
[21.6943]
```
    graph: &'db T::Graph,
```
Replacement in libpijul/src/pristine/mod.rs at line 388 [22.586748]
B:BD[21.6970] → [21.6970:7003]
```
) -> AdjacentIterator<'txn, T> {
```
[21.6970]
[21.7003]
```
) -> Result<AdjacentIterator<'txn, T>, TxnErr<T::GraphError>> {
```
Replacement in libpijul/src/pristine/mod.rs at line 391 [22.586748]
B:BD[21.7035] → [21.7035:7052]
```
        channel,
```
[21.7035]
[21.7052]
```
        graph,
```

Replacement in libpijul/src/pristine/mod.rs at line 398 [22.586748]

B:BD[22.607396] → [21.7137:7198]

pub(crate) fn iter_deleted_parents<'db, 'txn: 'db, T: TxnT>(

[22.607396]

[21.7198]

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

Replacement in libpijul/src/pristine/mod.rs at line 400 [22.586748]
B:BD[21.7216] → [21.7216:7246]
```
    channel: &'db Channel<T>,
```
[21.7216]
[21.7246]
```
    graph: &'db T::Graph,
```
Replacement in libpijul/src/pristine/mod.rs at line 402 [22.586748]
B:BD[21.7273] → [21.7273:7306]
```
) -> AdjacentIterator<'txn, T> {
```
[21.7273]
[21.7306]
```
) -> Result<AdjacentIterator<'txn, T>, TxnErr<T::GraphError>> {
```
Replacement in libpijul/src/pristine/mod.rs at line 405 [22.586748]
B:BD[21.7338] → [21.7338:7355]
```
        channel,
```
[21.7338]
[21.7355]
```
        graph,
```
Replacement in libpijul/src/pristine/mod.rs at line 412 [22.586748]
B:BD[21.7451] → [21.7451:7504]
```
pub(crate) fn iter_adj_all<'db, 'txn: 'db, T: TxnT>(
```
[21.7451]
[21.7504]
```
pub(crate) fn iter_adj_all<'db, 'txn: 'db, T: GraphTxnT>(
```
Replacement in libpijul/src/pristine/mod.rs at line 414 [22.586748]
B:BD[21.7522] → [21.7522:7552]
```
    channel: &'db Channel<T>,
```
[21.7522]
[21.7552]
```
    graph: &'db T::Graph,
```

Replacement in libpijul/src/pristine/mod.rs at line 416 [22.586748]

B:BD[21.7579] → [21.7579:7687]

) -> AdjacentIterator<'txn, T> {
    iter_adjacent(txn, channel, key, EdgeFlags::empty(), EdgeFlags::all())

[21.7579]

[21.7687]

) -> Result<AdjacentIterator<'txn, T>, TxnErr<T::GraphError>> {
    iter_adjacent(txn, graph, key, EdgeFlags::empty(), EdgeFlags::all())

Replacement in libpijul/src/pristine/mod.rs at line 420 [22.586748]

∅:D[21.7690] → [26.37849:37992]

B:BD[22.607396] → [26.37849:37992]

pub(crate) fn tree_path<T: TxnT>(txn: &T, v: Position<ChangeId>) -> Option<String> {
    if let Some(mut inode) = txn.get_revinodes(v, None) {

[21.7690]

[26.37992]

pub(crate) fn tree_path<T: TreeTxnT>(
    txn: &T,
    v: Position<ChangeId>,
) -> Result<Option<String>, TxnErr<T::TreeError>> {
    if let Some(mut inode) = txn.get_revinodes(v, None)? {

Replacement in libpijul/src/pristine/mod.rs at line 427 [22.586748]

B:BD[26.38066] → [26.38066:38129]

            if let Some(next) = txn.get_revtree(inode, None) {

[26.38066]

[26.38129]

            if let Some(next) = txn.get_revtree(inode, None)? {

Replacement in libpijul/src/pristine/mod.rs at line 432 [22.586748]
B:BD[26.38310] → [26.38310:38339]
```
                return None;
```
[26.38310]
[26.38339]
```
                return Ok(None);
```

Replacement in libpijul/src/pristine/mod.rs at line 439 [22.586748]

B:BD[26.38532] → [26.38532:38591]

            Some(result)
        } else {
            None

[26.38532]

[22.607771]

            return Ok(Some(result));

Deletion in libpijul/src/pristine/mod.rs at line 441 [22.586748]
B:BD[22.607781] → [26.38592:38618]
```
    } else {
        None
```
Insertion in libpijul/src/pristine/mod.rs at line 442 [22.586748]
[22.607802]
[26.38619]
```
    Ok(None)
```

Replacement in libpijul/src/pristine/mod.rs at line 445 [22.586748]

B:BD[22.607803] → [26.38622:38716]

pub(crate) fn internal<T: TxnT>(txn: &T, h: &Option<Hash>, p: ChangeId) -> Option<ChangeId> {

[22.607803]

[26.38716]

pub(crate) fn internal<T: GraphTxnT>(
    txn: &T,
    h: &Option<Hash>,
    p: ChangeId,
) -> Result<Option<ChangeId>, TxnErr<T::GraphError>> {

Replacement in libpijul/src/pristine/mod.rs at line 451 [22.586748]
B:BD[26.38731] → [26.38731:38781]
```
        Some(Hash::None) => Some(ChangeId::ROOT),
```
[26.38731]
[26.38781]
```
        Some(Hash::None) => Ok(Some(ChangeId::ROOT)),
```
Replacement in libpijul/src/pristine/mod.rs at line 453 [22.586748]
B:BD[26.38821] → [26.38821:38846]
```
        None => Some(p),
```
[26.38821]
[53.347]
```
        None => Ok(Some(p)),
```

Replacement in libpijul/src/pristine/mod.rs at line 458 [22.586748]

B:BD[23.17565] → [23.17565:17630]

#[error("Inconsistent change")]
pub struct InconsistentChange {}

[23.17565]

[23.17630]

pub enum InconsistentChange<T: std::error::Error + 'static> {
    #[error("Undeclared dependency")]
    UndeclaredDep,
    #[error(transparent)]
    Txn(T),
}
impl<T: std::error::Error + 'static> std::convert::From<TxnErr<T>> for InconsistentChange<T> {
    fn from(e: TxnErr<T>) -> Self {
        InconsistentChange::Txn(e.0)
    }
}

Replacement in libpijul/src/pristine/mod.rs at line 471 [22.586748]
∅:D[23.17631] → [26.38850:38887]
B:BD[53.354] → [26.38850:38887]
```
pub(crate) fn internal_pos<T: TxnT>(
```
[23.17631]
[26.38887]
```
pub(crate) fn internal_pos<T: GraphTxnT>(
```

Replacement in libpijul/src/pristine/mod.rs at line 475 [22.586748]

B:BD[26.38959] → [23.17632:17686]

) -> Result<Position<ChangeId>, InconsistentChange> {

[26.38959]

[54.0]

) -> Result<Position<ChangeId>, InconsistentChange<T::GraphError>> {

Replacement in libpijul/src/pristine/mod.rs at line 477 [22.586748]

B:BD[54.47] → [54.47:94]

        if let Some(p) = txn.get_internal(p) {

[54.47]

[54.94]

        if let Some(p) = txn.get_internal(p)? {

Replacement in libpijul/src/pristine/mod.rs at line 480 [22.586748]

B:BD[26.39254] → [23.17687:17734]

            return Err(InconsistentChange {});

[26.39254]

[54.167]

            return Err(InconsistentChange::UndeclaredDep);

Replacement in libpijul/src/pristine/mod.rs at line 492 [22.586748]
B:BD[26.39319] → [26.39319:39360]
```
pub(crate) fn iter_graph<'txn, T: TxnT>(
```
[26.39319]
[26.39360]
```
pub(crate) fn iter_graph<'txn, T: GraphTxnT>(
```

Replacement in libpijul/src/pristine/mod.rs at line 497 [22.586748]

B:BD[26.39446] → [26.39446:39512]

) -> Cursor<T, &'txn T, T::GraphCursor, Vertex<ChangeId>, Edge> {

[26.39446]

[39.4286]

) -> Result<Cursor<T, &'txn T, T::GraphCursor, Vertex<ChangeId>, Edge>, TxnErr<T::GraphError>> {

Replacement in libpijul/src/pristine/mod.rs at line 501 [22.586748]

B:BD[26.39578] → [26.39578:39650]

pub(crate) fn iter_graph_ref<T: TxnT, RT: std::ops::Deref<Target = T>>(

[26.39578]

[26.39650]

pub(crate) fn iter_graph_ref<T: GraphTxnT, RT: std::ops::Deref<Target = T>>(

Replacement in libpijul/src/pristine/mod.rs at line 506 [22.586748]

B:BD[26.39731] → [26.39731:39792]

) -> Cursor<T, RT, T::GraphCursor, Vertex<ChangeId>, Edge> {

[26.39731]

[39.4329]

) -> Result<Cursor<T, RT, T::GraphCursor, Vertex<ChangeId>, Edge>, TxnErr<T::GraphError>> {

Replacement in libpijul/src/pristine/mod.rs at line 510 [22.586748]
B:BD[26.39866] → [26.39866:39919]
```
pub(crate) fn changeid_log<'db, 'txn: 'db, T: TxnT>(
```
[26.39866]
[26.39919]
```
pub(crate) fn changeid_log<'db, 'txn: 'db, T: ChannelTxnT>(
```

Replacement in libpijul/src/pristine/mod.rs at line 514 [22.586748]

B:BD[26.39982] → [26.39982:40056]

) -> Cursor<T, &'txn T, T::RevchangesetCursor, u64, (ChangeId, Merkle)> {

[26.39982]

[26.40056]

) -> Result<Cursor<T, &'txn T, T::RevchangesetCursor, u64, (ChangeId, Merkle)>, TxnErr<T::GraphError>>
{

Replacement in libpijul/src/pristine/mod.rs at line 519 [22.586748]
B:BD[26.40128] → [26.40128:40182]
```
pub(crate) fn current_state<'db, 'txn: 'db, T: TxnT>(
```
[26.40128]
[26.40182]
```
pub(crate) fn current_state<'db, 'txn: 'db, T: ChannelTxnT>(
```

Replacement in libpijul/src/pristine/mod.rs at line 522 [22.586748]

B:BD[26.40230] → [16.197:211]

∅:D[16.211] → [26.40252:40311]

B:BD[26.40252] → [26.40252:40311]

) -> Merkle {
    txn.rev_cursor_revchangeset(&channel.revchanges, None)

[26.40230]

[26.40311]

) -> Result<Merkle, TxnErr<T::GraphError>> {
    if let Some(e) = txn
        .rev_cursor_revchangeset(&channel.revchanges, None)?

Replacement in libpijul/src/pristine/mod.rs at line 526 [22.586748]

B:BD[26.40327] → [26.40327:40357]

B:BD[26.40357] → [16.212:247]

        .map(|(_, (_, m))| m)
        .unwrap_or(Merkle::zero())

[26.40327]

[26.40357]

    {
        let (_, (_, m)) = e?;
        Ok(m)
    } else {
        Ok(Merkle::zero())
    }

Replacement in libpijul/src/pristine/mod.rs at line 534 [22.586748]

B:BD[26.40360] → [26.40360:40434]

pub(crate) fn changeid_log_ref<T: TxnT, RT: std::ops::Deref<Target = T>>(

[26.40360]

[26.40434]

pub(crate) fn changeid_log_ref<T: ChannelTxnT, RT: std::ops::Deref<Target = T>>(

Replacement in libpijul/src/pristine/mod.rs at line 538 [22.586748]

B:BD[26.40488] → [26.40488:40634]

) -> Cursor<T, RT, T::RevchangesetCursor, u64, (ChangeId, Merkle)> {
    T::cursor_revchangeset_ref(txn, &channel.revchanges, Some((from, None)))

[26.40488]

[26.40634]

) -> Result<Cursor<T, RT, T::RevchangesetCursor, u64, (ChangeId, Merkle)>, TxnErr<T::GraphError>> {
    Ok(T::cursor_revchangeset_ref(
        txn,
        &channel.revchanges,
        Some((from, None)),
    )?)

Replacement in libpijul/src/pristine/mod.rs at line 546 [22.586748]
B:BD[26.40637] → [26.40637:40694]
```
pub(crate) fn changeid_rev_log<'db, 'txn: 'db, T: TxnT>(
```
[26.40637]
[26.40694]
```
pub(crate) fn changeid_rev_log<'db, 'txn: 'db, T: ChannelTxnT>(
```

Replacement in libpijul/src/pristine/mod.rs at line 550 [22.586748]

B:BD[26.40765] → [26.40765:40926]

) -> RevCursor<T, &'txn T, T::RevchangesetCursor, u64, (ChangeId, Merkle)> {
    txn.rev_cursor_revchangeset(&channel.revchanges, from.map(|from| (from, None)))

[26.40765]

[26.40926]

) -> Result<
    RevCursor<T, &'txn T, T::RevchangesetCursor, u64, (ChangeId, Merkle)>,
    TxnErr<T::GraphError>,
> {
    Ok(txn.rev_cursor_revchangeset(&channel.revchanges, from.map(|from| (from, None)))?)

Replacement in libpijul/src/pristine/mod.rs at line 557 [22.586748]

B:BD[26.40929] → [26.40929:40982]

pub(crate) fn log_for_path<'txn, 'channel, T: TxnT>(

[26.40929]

[26.40982]

pub(crate) fn log_for_path<
    'txn,
    'channel,
    T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
>(

Replacement in libpijul/src/pristine/mod.rs at line 566 [22.586748]

B:BD[26.41089] → [26.41089:41239]

) -> PathChangeset<'channel, 'txn, T> {
    PathChangeset {
        iter: txn.cursor_revchangeset(&channel.revchanges, Some((from_timestamp, None))),

[26.41089]

[26.41239]

) -> Result<PathChangeset<'channel, 'txn, T>, TxnErr<T::GraphError>> {
    Ok(PathChangeset {
        iter: txn.cursor_revchangeset(&channel.revchanges, Some((from_timestamp, None)))?,

Replacement in libpijul/src/pristine/mod.rs at line 572 [22.586748]
∅:D[26.41282] → [22.608084:608090]
B:BD[22.608084] → [22.608084:608090]
```
    }
```
[26.41282]
[26.41283]
```
    })
```

Replacement in libpijul/src/pristine/mod.rs at line 575 [22.586748]

B:BD[22.608091] → [26.41286:41343]

pub(crate) fn rev_log_for_path<'txn, 'channel, T: TxnT>(

[22.608091]

[26.41343]

pub(crate) fn rev_log_for_path<
    'txn,
    'channel,
    T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
>(

Replacement in libpijul/src/pristine/mod.rs at line 584 [22.586748]

B:BD[26.41450] → [26.41450:41610]

) -> RevPathChangeset<'channel, 'txn, T> {
    RevPathChangeset {
        iter: txn.rev_cursor_revchangeset(&channel.revchanges, Some((from_timestamp, None))),

[26.41450]

[26.41610]

) -> Result<RevPathChangeset<'channel, 'txn, T>, TxnErr<T::GraphError>> {
    Ok(RevPathChangeset {
        iter: txn.rev_cursor_revchangeset(&channel.revchanges, Some((from_timestamp, None)))?,

Replacement in libpijul/src/pristine/mod.rs at line 590 [22.586748]
∅:D[26.41653] → [53.525:531]
B:BD[53.525] → [53.525:531]
```
    }
```
[26.41653]
[26.41654]
```
    })
```
Replacement in libpijul/src/pristine/mod.rs at line 594 [22.586748]
B:BD[26.41708] → [26.41708:41742]
```
pub(crate) fn test_edge<T: TxnT>(
```
[26.41708]
[26.41742]
```
pub(crate) fn test_edge<T: GraphTxnT>(
```
Replacement in libpijul/src/pristine/mod.rs at line 596 [22.586748]
B:BD[26.41755] → [26.41755:41781]
```
    channel: &Channel<T>,
```
[26.41755]
[26.41781]
```
    channel: &T::Graph,
```
Replacement in libpijul/src/pristine/mod.rs at line 601 [22.586748]
B:BD[26.41875] → [26.41875:41887]
```
) -> bool {
```
[26.41875]
[26.41887]
```
) -> Result<bool, TxnErr<T::GraphError>> {
```

Replacement in libpijul/src/pristine/mod.rs at line 613 [22.586748]

B:BD[26.42133] → [26.42133:42282]

    let mut cursor = txn.cursor_graph(&channel.graph, Some((key, Some(edge))));
    let (a_, b_) = cursor.next().unwrap();
    a_.change == a.change

[26.42133]

[26.42282]

    let mut cursor = txn.cursor_graph(&channel, Some((key, Some(edge))))?;
    let (a_, b_) = cursor.next().unwrap()?;
    Ok(a_.change == a.change

Replacement in libpijul/src/pristine/mod.rs at line 620 [22.586748]
B:BD[26.42390] → [26.42390:42414]
```
        && b_.dest == b
```
[26.42390]
[26.42414]
```
        && b_.dest == b)
```

Replacement in libpijul/src/pristine/mod.rs at line 624 [22.586748]

B:BD[26.42459] → [26.42459:42740]

B:BD[26.42740] → [43.270:419]

pub(crate) fn is_alive<T: TxnT>(txn: &T, channel: &Channel<T>, a: Vertex<ChangeId>) -> bool {
    a.is_root()
        || iter_adjacent(
            txn,
            channel,
            a,
            EdgeFlags::PARENT,
            EdgeFlags::all() - EdgeFlags::DELETED,
        )
        .any(|e| {
            !e.flag.contains(EdgeFlags::PSEUDO)
                && (e.flag.contains(EdgeFlags::BLOCK) || a.is_empty())
        })

[26.42459]

[26.42868]

pub(crate) fn is_alive<T: GraphTxnT>(
    txn: &T,
    channel: &T::Graph,
    a: Vertex<ChangeId>,
) -> Result<bool, TxnErr<T::GraphError>> {
    if a.is_root() {
        return Ok(true);
    }
    for e in iter_adjacent(
        txn,
        channel,
        a,
        EdgeFlags::PARENT,
        EdgeFlags::all() - EdgeFlags::DELETED,
    )? {
        let e = e?;
        if !e.flag.contains(EdgeFlags::PSEUDO)
            && (e.flag.contains(EdgeFlags::BLOCK) || a.is_empty())
        {
            return Ok(true);
        }
    }
    Ok(false)

Replacement in libpijul/src/pristine/mod.rs at line 649 [22.586748]

B:BD[22.608172] → [26.42871:43003]

pub(crate) fn make_changeid<T: TxnT>(txn: &T, h: &Hash) -> ChangeId {
    if let Some(h) = txn.get_internal(*h) {
        return h;

[22.608172]

[26.43003]

pub(crate) fn make_changeid<T: GraphTxnT>(
    txn: &T,
    h: &Hash,
) -> Result<ChangeId, TxnErr<T::GraphError>> {
    if let Some(h) = txn.get_internal(*h)? {
        return Ok(h);

Replacement in libpijul/src/pristine/mod.rs at line 659 [22.586748]
B:BD[26.43100] → [26.43100:43145]
```
        Hash::None => return ChangeId::ROOT,
```
[26.43100]
[26.43145]
```
        Hash::None => return Ok(ChangeId::ROOT),
```
Replacement in libpijul/src/pristine/mod.rs at line 662 [22.586748]
B:BD[26.43225] → [26.43225:43267]
```
    while txn.get_external(p).is_some() {
```
[26.43225]
[26.43267]
```
    while txn.get_external(p)?.is_some() {
```
Replacement in libpijul/src/pristine/mod.rs at line 665 [22.586748]
B:BD[22.608592] → [26.43316:43322]
```
    p
```
[22.608592]
[26.43322]
```
    Ok(p)
```
Replacement in libpijul/src/pristine/mod.rs at line 669 [22.586748]
B:BD[26.43350] → [26.43350:43405]
```
pub fn debug_tree<P: AsRef<std::path::Path>, T: TxnT>(
```
[26.43350]
[26.43405]
```
pub fn debug_tree<P: AsRef<std::path::Path>, T: TreeTxnT>(
```

Replacement in libpijul/src/pristine/mod.rs at line 678 [22.586748]

B:BD[26.43626] → [26.43626:43699]

    for t in txn.iter_tree(root, None) {
        writeln!(f, "{:?}", t)?

[26.43626]

[26.43699]

    for t in txn.iter_tree(root, None).unwrap() {
        writeln!(f, "{:?}", t.unwrap())?

Replacement in libpijul/src/pristine/mod.rs at line 685 [22.586748]
B:BD[26.43744] → [26.43744:43788]
```
pub fn debug_tree_print<T: TxnT>(txn: &T) {
```
[26.43744]
[26.43788]
```
pub fn debug_tree_print<T: TreeTxnT>(txn: &T) {
```

Replacement in libpijul/src/pristine/mod.rs at line 690 [22.586748]

B:BD[26.43904] → [26.43904:43971]

    for t in txn.iter_tree(root, None) {
        debug!("{:?}", t)

[26.43904]

[22.609454]

    for t in txn.iter_tree(root, None).unwrap() {
        debug!("{:?}", t.unwrap())

Replacement in libpijul/src/pristine/mod.rs at line 698 [22.586748]

B:BD[26.44179] → [26.44179:44237]

pub fn debug_to_file<P: AsRef<std::path::Path>, T: TxnT>(

[26.44179]

[26.44237]

pub fn debug_to_file<P: AsRef<std::path::Path>, T: ChannelTxnT>(

Replacement in libpijul/src/pristine/mod.rs at line 705 [22.586748]

B:BD[26.44404] → [26.44404:44488]

    let channel = channel.r.borrow();
    let done = debug(txn, &channel, &mut f)?;

[26.44404]

[26.44488]

    let done = debug(txn, &channel.borrow().graph, &mut f)?;

Replacement in libpijul/src/pristine/mod.rs at line 712 [22.586748]
B:BD[26.44585] → [26.44585:44643]
```
pub fn debug_revtree<P: AsRef<std::path::Path>, T: TxnT>(
```
[26.44585]
[26.44643]
```
pub fn debug_revtree<P: AsRef<std::path::Path>, T: TreeTxnT>(
```

Replacement in libpijul/src/pristine/mod.rs at line 717 [22.586748]

B:BD[26.44748] → [26.44748:44831]

    for t in txn.iter_revtree(Inode::ROOT, None) {
        writeln!(f, "{:?}", t)?

[26.44748]

[22.610454]

    for t in txn.iter_revtree(Inode::ROOT, None).unwrap() {
        writeln!(f, "{:?}", t.unwrap())?

Replacement in libpijul/src/pristine/mod.rs at line 724 [22.586748]

B:BD[26.44871] → [26.44871:44995]

pub fn debug_revtree_print<T: TxnT>(txn: &T) {
    for t in txn.iter_revtree(Inode::ROOT, None) {
        debug!("{:?}", t)

[26.44871]

[22.611449]

pub fn debug_revtree_print<T: TreeTxnT>(txn: &T) {
    for t in txn.iter_revtree(Inode::ROOT, None).unwrap() {
        debug!("{:?}", t.unwrap())

Replacement in libpijul/src/pristine/mod.rs at line 731 [22.586748]
B:BD[26.45024] → [26.45024:45064]
```
pub fn debug_inodes<T: TxnT>(txn: &T) {
```
[26.45024]
[26.45064]
```
pub fn debug_inodes<T: TreeTxnT>(txn: &T) {
```

Replacement in libpijul/src/pristine/mod.rs at line 733 [22.586748]

B:BD[26.45092] → [26.45092:45166]

    for t in txn.iter_inodes() {
        debug!("debug_inodes = {:?}", t)

[26.45092]

[26.45166]

    for t in txn.iter_inodes().unwrap() {
        debug!("debug_inodes = {:?}", t.unwrap())

Replacement in libpijul/src/pristine/mod.rs at line 740 [22.586748]
B:BD[41.1235] → [41.1235:1278]
```
pub fn debug_revinodes<T: TxnT>(txn: &T) {
```
[41.1235]
[41.1278]
```
pub fn debug_revinodes<T: TreeTxnT>(txn: &T) {
```

Replacement in libpijul/src/pristine/mod.rs at line 742 [22.586748]

B:BD[41.1309] → [41.1309:1389]

    for t in txn.iter_revinodes() {
        debug!("debug_revinodes = {:?}", t)

[41.1309]

[41.1389]

    for t in txn.iter_revinodes().unwrap() {
        debug!("debug_revinodes = {:?}", t.unwrap())

Replacement in libpijul/src/pristine/mod.rs at line 751 [22.586748]
B:BD[26.45354] → [26.45354:45387]
```
pub fn debug<W: Write, T: TxnT>(
```
[26.45354]
[26.45387]
```
pub fn debug<W: Write, T: GraphTxnT>(
```
Replacement in libpijul/src/pristine/mod.rs at line 753 [22.586748]
B:BD[26.45400] → [26.45400:45426]
```
    channel: &Channel<T>,
```
[26.45400]
[26.45426]
```
    channel: &T::Graph,
```
Replacement in libpijul/src/pristine/mod.rs at line 756 [22.586748]
∅:D[23.17878] → [55.294:351]
B:BD[26.45475] → [55.294:351]
```
    let cursor = txn.cursor_graph(&channel.graph, None);
```
[23.17878]
[26.45536]
```
    let cursor = txn.cursor_graph(&channel, None).unwrap();
```
Replacement in libpijul/src/pristine/mod.rs at line 760 [22.586748]
B:BD[26.45655] → [56.301:328]
```
    for (k, v) in cursor {
```
[26.45655]
[26.45700]
```
    for x in cursor {
        let (k, v) = x.unwrap();
```
Replacement in libpijul/src/pristine/mod.rs at line 773 [22.586748]
B:BD[26.45951] → [26.45951:45980]
```
pub fn check_alive<T: TxnT>(
```
[22.612336]
[26.45980]
```
pub fn check_alive<T: ChannelTxnT>(
```
Replacement in libpijul/src/pristine/mod.rs at line 775 [22.586748]
B:BD[26.45993] → [26.45993:46022]
```
    channel: &ChannelRef<T>,
```
[26.45993]
[26.46022]
```
    channel: &T::Graph,
```
Deletion in libpijul/src/pristine/mod.rs at line 780 [22.586748]
B:BD[26.46145] → [26.46145:46183]
∅:D[26.46183] → [22.613571:613572]
B:BD[22.613571] → [22.613571:613572]
```
    let channel = channel.r.borrow();
```

Replacement in libpijul/src/pristine/mod.rs at line 793 [22.586748]

B:BD[26.46586] → [26.46586:46598]

) {

[26.46586]

[26.46598]

        )
        .unwrap()
        {
            let e = e.unwrap();

Replacement in libpijul/src/pristine/mod.rs at line 804 [22.586748]
B:BD[26.46782] → [55.352:409]
```
    let cursor = txn.cursor_graph(&channel.graph, None);
```
[26.46782]
[26.46843]
```
    let cursor = txn.cursor_graph(&channel, None);
```
Replacement in libpijul/src/pristine/mod.rs at line 810 [22.586748]
B:BD[26.47042] → [56.329:356]
```
    for (k, v) in cursor {
```
[26.47042]
[26.47087]
```
    for x in cursor.unwrap() {
        let (k, v) = x.unwrap();
```

Replacement in libpijul/src/pristine/mod.rs at line 815 [22.586748]

B:BD[26.47231] → [26.47231:47331]

                reachable_pseudo.push((k0, find_file(txn, &channel, k0, &mut stack, &mut visited)))

[26.47231]

[22.614588]

                reachable_pseudo.push((
                    k0,
                    find_file(txn, &channel, k0, &mut stack, &mut visited).unwrap(),
                ))

Replacement in libpijul/src/pristine/mod.rs at line 840 [22.586748]

B:BD[39.4618] → [39.4618:4696]

            let file = find_file(txn, &channel, k, &mut stack, &mut visited);

[39.4618]

[39.4696]

            let file = find_file(txn, &channel, k, &mut stack, &mut visited).unwrap();

Replacement in libpijul/src/pristine/mod.rs at line 845 [22.586748]

B:BD[26.48127] → [26.48127:48220]

        reachable_pseudo.push((k0, find_file(txn, &channel, k0, &mut stack, &mut visited)));

[26.48127]

[26.48220]

        reachable_pseudo.push((
            k0,
            find_file(txn, &channel, k0, &mut stack, &mut visited).unwrap(),
        ));

Replacement in libpijul/src/pristine/mod.rs at line 854 [22.586748]
B:BD[26.48285] → [26.48285:48308]
```
fn find_file<T: TxnT>(
```
[26.48272]
[26.48308]
```
fn find_file<T: GraphTxnT>(
```
Replacement in libpijul/src/pristine/mod.rs at line 856 [22.586748]
B:BD[26.48321] → [26.48321:48347]
```
    channel: &Channel<T>,
```
[26.48321]
[26.48347]
```
    channel: &T::Graph,
```
Replacement in libpijul/src/pristine/mod.rs at line 860 [22.586748]
B:BD[26.48456] → [26.48456:48488]
```
) -> Option<Vertex<ChangeId>> {
```
[26.48456]
[26.48488]
```
) -> Result<Option<Vertex<ChangeId>>, TxnErr<T::GraphError>> {
```

Replacement in libpijul/src/pristine/mod.rs at line 869 [22.586748]

B:BD[26.48684] → [26.48684:48773]

        for e in iter_adjacent(txn, &channel, kk, EdgeFlags::PARENT, EdgeFlags::all()) {

[26.48684]

[26.48773]

        for e in iter_adjacent(txn, &channel, kk, EdgeFlags::PARENT, EdgeFlags::all())? {
            let e = e?;

Replacement in libpijul/src/pristine/mod.rs at line 880 [22.586748]
B:BD[22.616290] → [26.49030:49039]
```
    file
```
[22.616290]
[26.49039]
```
    Ok(file)
```
Replacement in libpijul/src/pristine/mod.rs at line 883 [22.586748]
B:BD[42.451] → [42.451:489]
```
pub fn debug_root<W: Write, T: TxnT>(
```
[22.616291]
[26.49091]
```
pub fn debug_root<W: Write, T: GraphTxnT>(
```
Replacement in libpijul/src/pristine/mod.rs at line 885 [22.586748]
B:BD[26.49104] → [26.49104:49130]
```
    channel: &Channel<T>,
```
[26.49104]
[26.49130]
```
    channel: &T::Graph,
```

Replacement in libpijul/src/pristine/mod.rs at line 898 [22.586748]

B:BD[26.49443] → [21.7691:7741]

        for e in iter_adj_all(txn, &channel, v) {

[26.49443]

[42.507]

        for e in iter_adj_all(txn, &channel, v).unwrap() {
            let e = e.unwrap();

Replacement in libpijul/src/pristine/mod.rs at line 928 [22.586748]
B:BD[22.617477] → [22.617477:617520]
```
fn debug_edge<T: TxnT, W: std::io::Write>(
```
[22.617477]
[22.617520]
```
fn debug_edge<T: GraphTxnT, W: std::io::Write>(
```
Replacement in libpijul/src/pristine/mod.rs at line 930 [22.586748]
B:BD[22.617533] → [22.617533:617559]
```
    channel: &Channel<T>,
```
[22.617533]
[22.617559]
```
    channel: &T::Graph,
```

Replacement in libpijul/src/pristine/mod.rs at line 1035 [22.586748]

B:BD[22.620388] → [22.620388:620464]

pub struct Cursor<T: TxnT, RT: std::ops::Deref<Target = T>, Cursor, K, V> {

[22.620373]

[22.620464]

pub struct Cursor<T: Sized, RT: std::ops::Deref<Target = T>, Cursor, K, V> {

Replacement in libpijul/src/pristine/mod.rs at line 1041 [22.586748]

B:BD[22.620597] → [22.620597:620676]

pub struct RevCursor<T: TxnT, RT: std::ops::Deref<Target = T>, Cursor, K, V> {

[22.620582]

[22.620676]

pub struct RevCursor<T: Sized, RT: std::ops::Deref<Target = T>, Cursor, K, V> {

Replacement in libpijul/src/pristine/mod.rs at line 1047 [22.586748]

B:BD[22.620794] → [22.620794:621360]

initialized_cursor!(graph, Vertex<ChangeId>, Edge);
initialized_cursor!(changeset, ChangeId, u64);
initialized_cursor!(revchangeset, u64, (ChangeId, Merkle));
initialized_rev_cursor!(revchangeset, u64, (ChangeId, Merkle));
initialized_cursor!(tree, OwnedPathId, Inode);
initialized_cursor!(revtree, Inode, OwnedPathId);
initialized_cursor!(dep, ChangeId, ChangeId);
initialized_cursor!(partials, SmallString, Position<ChangeId>);
initialized_cursor!(rev_touched_files, ChangeId, Position<ChangeId>);
initialized_cursor!(touched_files, Position<ChangeId>, ChangeId);

[22.620794]

[22.621360]

initialized_cursor!(graph, Vertex<ChangeId>, Edge, GraphTxnT, GraphError);
initialized_cursor!(changeset, ChangeId, u64, ChannelTxnT, GraphError);
initialized_cursor!(
    revchangeset,
    u64,
    (ChangeId, Merkle),
    ChannelTxnT,
    GraphError
);
initialized_rev_cursor!(
    revchangeset,
    u64,
    (ChangeId, Merkle),
    ChannelTxnT,
    GraphError
);
initialized_cursor!(tree, OwnedPathId, Inode, TreeTxnT, TreeError);
initialized_cursor!(revtree, Inode, OwnedPathId, TreeTxnT, TreeError);
initialized_cursor!(dep, ChangeId, ChangeId, DepsTxnT, DepsError);
initialized_cursor!(
    partials,
    SmallString,
    Position<ChangeId>,
    TreeTxnT,
    TreeError
);
initialized_cursor!(
    rev_touched_files,
    ChangeId,
    Position<ChangeId>,
    DepsTxnT,
    DepsError
);
initialized_cursor!(
    touched_files,
    Position<ChangeId>,
    ChangeId,
    DepsTxnT,
    DepsError
);

Replacement in libpijul/src/pristine/mod.rs at line 1089 [22.586748]

B:BD[22.621492] → [22.621492:621548]

initialized_cursor!(inodes, Inode, Position<ChangeId>);

[22.621464]

[41.1431]

initialized_cursor!(inodes, Inode, Position<ChangeId>, TreeTxnT, TreeError);

Replacement in libpijul/src/pristine/mod.rs at line 1091 [22.586748]

B:BD[41.1456] → [41.1456:1515]

initialized_cursor!(revinodes, Position<ChangeId>, Inode);

[41.1456]

[22.621548]

initialized_cursor!(revinodes, Position<ChangeId>, Inode, TreeTxnT, TreeError);

Replacement in libpijul/src/pristine/mod.rs at line 1094 [22.586748]
B:BD[22.621660] → [22.621660:621705]
```
pub struct AdjacentIterator<'txn, T: TxnT> {
```
[22.621645]
[22.621705]
```
pub struct AdjacentIterator<'txn, T: GraphTxnT> {
```

Replacement in libpijul/src/pristine/mod.rs at line 1102 [22.586748]

B:BD[22.621907] → [22.621907:621990]

impl<'txn, T: TxnT> Iterator for AdjacentIterator<'txn, T> {
    type Item = Edge;

[22.621907]

[22.621990]

impl<'txn, T: GraphTxnT> Iterator for AdjacentIterator<'txn, T> {
    type Item = Result<Edge, TxnErr<T::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 1106 [22.586748]

B:BD[22.622052] → [22.622052:622420]

            if let Some((v, e)) = self.it.next() {
                debug!("adjacent iterator: {:?} {:?}", v, e);
                if v == self.key {
                    if e.flag >= self.min_flag {
                        if e.flag <= self.max_flag {
                            return Some(e);
                        } else {
                            return None;

[22.622052]

[22.622420]

            match self.it.next() {
                Some(Ok((v, e))) => {
                    debug!("adjacent iterator: {:?} {:?}", v, e);
                    if v == self.key {
                        if e.flag >= self.min_flag {
                            if e.flag <= self.max_flag {
                                return Some(Ok(e));
                            } else {
                                return None;
                            }

Insertion in libpijul/src/pristine/mod.rs at line 1117 [22.586748]

[22.622446]

                    } else if v > self.key {
                        return None;

Replacement in libpijul/src/pristine/mod.rs at line 1120 [22.586748]

B:BD[22.622468] → [22.622468:622509]

                } else if v > self.key {

[22.622468]

[22.622509]

                }
                Some(Err(e)) => return Some(Err(e)),
                None => {
                    debug!("adjacent iterator: over");

Deletion in libpijul/src/pristine/mod.rs at line 1126 [22.586748]

B:BD[22.622560] → [22.622560:622661]

            } else {
                debug!("adjacent iterator: over");
                return None;

Replacement in libpijul/src/pristine/mod.rs at line 1131 [22.586748]

B:BD[22.622694] → [22.622694:622756]

pub struct PathChangeset<'channel, 'txn: 'channel, T: TxnT> {

[22.622694]

[22.622756]

pub struct PathChangeset<'channel, 'txn: 'channel, T: ChannelTxnT + DepsTxnT> {

Replacement in libpijul/src/pristine/mod.rs at line 1138 [22.586748]

B:BD[22.622919] → [22.622919:622984]

pub struct RevPathChangeset<'channel, 'txn: 'channel, T: TxnT> {

[22.622919]

[22.622984]

pub struct RevPathChangeset<'channel, 'txn: 'channel, T: ChannelTxnT + DepsTxnT> {

Replacement in libpijul/src/pristine/mod.rs at line 1145 [22.586748]

B:BD[22.623150] → [22.623150:623260]

impl<'channel, 'txn: 'channel, T: TxnT> Iterator for PathChangeset<'channel, 'txn, T> {
    type Item = Hash;

[22.623150]

[22.623260]

impl<
        'channel,
        'txn: 'channel,
        T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
    > Iterator for PathChangeset<'channel, 'txn, T>
{
    type Item = Result<Hash, TxnErr<T::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 1153 [22.586748]

B:BD[22.623307] → [22.623307:623453]

        while let Some((_, (changeid, _))) = self.iter.next() {
            for (p, touched) in self.txn.iter_rev_touched_files(changeid, None) {

[22.623307]

[22.623453]

        while let Some(x) = self.iter.next() {
            let (_, (changeid, _)) = match x {
                Ok(x) => x,
                Err(e) => return Some(Err(e)),
            };
            let iter = match self.txn.iter_rev_touched_files(changeid, None) {
                Ok(iter) => iter,
                Err(e) => return Some(Err(e)),
            };
            for x in iter {
                let (p, touched) = match x {
                    Ok(x) => x,
                    Err(e) => return Some(Err(e)),
                };

Replacement in libpijul/src/pristine/mod.rs at line 1172 [22.586748]

B:BD[22.623603] → [22.623603:623742]

                if is_ancestor_of(self.txn, self.channel, self.key, touched) {
                    return self.txn.get_external(changeid);

[22.623603]

[22.623742]

                match is_ancestor_of(self.txn, &self.channel.graph, self.key, touched) {
                    Ok(true) => return self.txn.get_external(changeid).transpose(),
                    Err(e) => return Some(Err(e)),
                    Ok(false) => {}

Replacement in libpijul/src/pristine/mod.rs at line 1183 [22.586748]

B:BD[22.623806] → [22.623806:623919]

impl<'channel, 'txn: 'channel, T: TxnT> Iterator for RevPathChangeset<'channel, 'txn, T> {
    type Item = Hash;

[22.623806]

[22.623919]

impl<
        'channel,
        'txn: 'channel,
        T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
    > Iterator for RevPathChangeset<'channel, 'txn, T>
{
    type Item = Result<Hash, TxnErr<T::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 1191 [22.586748]

B:BD[22.623966] → [22.623966:624112]

        while let Some((_, (changeid, _))) = self.iter.next() {
            for (p, touched) in self.txn.iter_rev_touched_files(changeid, None) {

[22.623966]

[22.624112]

        loop {
            let changeid = match self.iter.next()? {
                Err(e) => return Some(Err(e)),
                Ok((_, (changeid, _))) => changeid,
            };
            let iter = match self.txn.iter_rev_touched_files(changeid, None) {
                Ok(iter) => iter,
                Err(e) => return Some(Err(e)),
            };
            for x in iter {
                let (p, touched) = match x {
                    Ok(x) => x,
                    Err(e) => return Some(Err(e)),
                };

Replacement in libpijul/src/pristine/mod.rs at line 1210 [22.586748]

B:BD[22.624262] → [22.624262:624401]

                if is_ancestor_of(self.txn, self.channel, self.key, touched) {
                    return self.txn.get_external(changeid);

[22.624262]

[22.624401]

                match is_ancestor_of(self.txn, &self.channel.graph, self.key, touched) {
                    Ok(true) => return self.txn.get_external(changeid).transpose(),
                    Err(e) => return Some(Err(e)),
                    Ok(false) => {}

Deletion in libpijul/src/pristine/mod.rs at line 1217 [22.586748]
B:BD[22.624443] → [22.624443:624456]
```
        None
```
Replacement in libpijul/src/pristine/mod.rs at line 1220 [22.586748]
B:BD[22.624465] → [22.624465:624493]
```
fn is_ancestor_of<T: TxnT>(
```
[22.624465]
[22.624493]
```
fn is_ancestor_of<T: GraphTxnT>(
```
Replacement in libpijul/src/pristine/mod.rs at line 1222 [22.586748]
B:BD[22.624506] → [22.624506:624532]
```
    channel: &Channel<T>,
```
[22.624506]
[22.624532]
```
    channel: &T::Graph,
```
Replacement in libpijul/src/pristine/mod.rs at line 1225 [22.586748]
B:BD[22.624586] → [22.624586:624598]
```
) -> bool {
```
[22.624586]
[22.624598]
```
) -> Result<bool, TxnErr<T::GraphError>> {
```
Replacement in libpijul/src/pristine/mod.rs at line 1232 [22.586748]
B:BD[22.624799] → [22.624799:624824]
```
            return true;
```
[22.624799]
[22.624824]
```
            return Ok(true);
```
Replacement in libpijul/src/pristine/mod.rs at line 1243 [22.586748]
B:BD[22.625107] → [22.625107:625119]
```
        ) {
```
[22.625107]
[22.625119]
```
        )? {
            let p = p?;
```
Replacement in libpijul/src/pristine/mod.rs at line 1253 [22.586748]
B:BD[22.625458] → [22.625458:625474]
```
            ) {
```
[22.625458]
[22.625474]
```
            )? {
                let pp = pp?;
```
Replacement in libpijul/src/pristine/mod.rs at line 1256 [22.586748]
B:BD[22.625508] → [22.625508:625541]
```
                    return true;
```
[22.625508]
[22.625541]
```
                    return Ok(true);
```
Replacement in libpijul/src/pristine/mod.rs at line 1262 [22.586748]
B:BD[22.625625] → [22.625625:625635]
```
    false
```
[22.625625]
[22.625635]
```
    Ok(false)
```
Replacement in libpijul/src/pristine/mod.rs at line 1271 [22.586748]
B:BD[22.625794] → [22.625794:625825]
```
    type Item = ChannelRef<T>;
```
[22.625794]
[22.625825]
```
    type Item = Result<ChannelRef<T>, TxnErr<T::GraphError>>;
```

Replacement in libpijul/src/pristine/mod.rs at line 1273 [22.586748]

B:BD[22.625872] → [22.625872:626130]

        let next: Option<(SmallString, (u64, u64, u64, u64, u64, u64))> =
            self.txn.cursor_channels_next(&mut self.cursor);
        if let Some((name, _)) = next {
            self.txn.load_channel(name.as_str())
        } else {
            None

[22.625872]

[22.626130]

        // Option<(SmallString, (u64, u64, u64, u64, u64, u64))>
        match self.txn.cursor_channels_next(&mut self.cursor) {
            Err(e) => Some(Err(e)),
            Ok(Some((name, _))) => self.txn.load_channel(name.as_str()).transpose(),
            Ok(None) => None,

Replacement in libpijul/src/pristine/mod.rs at line 1288 [22.586748]
B:BD[22.626304] → [22.626304:626334]
```
    type Item = RemoteRef<T>;
```
[22.626304]
[22.626334]
```
    type Item = Result<RemoteRef<T>, TxnErr<T::GraphError>>;
```

Replacement in libpijul/src/pristine/mod.rs at line 1290 [22.586748]

B:BD[22.626381] → [22.626381:626622]

        let next: Option<(SmallString, (u64, u64, u64))> =
            self.txn.cursor_remotes_next(&mut self.cursor);
        if let Some((name, _)) = next {
            self.txn.load_remote(name.as_str())
        } else {
            None

[22.626381]

[22.626622]

        match self.txn.cursor_remotes_next(&mut self.cursor) {
            Ok(Some((name, _))) => self.txn.load_remote(name.as_str()).transpose(),
            Ok(None) => None,
            Err(e) => Some(Err(e)),

Replacement in libpijul/src/pristine/mod.rs at line 1298 [22.586748]

B:BD[22.626696] → [22.626696:626843]

/// The trait of immutable transactions.
pub trait MutTxnT: TxnT {
    put_del!(internal, Hash, ChangeId);
    put_del!(external, ChangeId, Hash);

[22.626696]

[22.626843]

pub trait GraphMutTxnT: GraphTxnT {
    put_del!(internal, Hash, ChangeId, GraphError);
    put_del!(external, ChangeId, Hash, GraphError);

Deletion in libpijul/src/pristine/mod.rs at line 1302 [22.586748]

B:BD[22.626844] → [22.626844:627224]

B:BD[22.628320] → [22.628320:628321]

    put_del!(inodes, Inode, Position<ChangeId>);
    put_del!(revinodes, Position<ChangeId>, Inode);
    put_del!(tree, PathId, Inode);
    put_del!(revtree, Inode, PathId);
    put_del!(dep, ChangeId, ChangeId);
    put_del!(revdep, ChangeId, ChangeId);
    put_del!(touched_files, Position<ChangeId>, ChangeId);
    put_del!(rev_touched_files, ChangeId, Position<ChangeId>);

Replacement in libpijul/src/pristine/mod.rs at line 1308 [22.586748]
B:BD[22.629258] → [23.17914:17950]
```
    ) -> Result<bool, Self::Error>;
```
[22.629258]
[22.629296]
```
    ) -> Result<bool, TxnErr<Self::GraphError>>;
```
Replacement in libpijul/src/pristine/mod.rs at line 1316 [22.586748]
B:BD[22.629546] → [23.17951:17987]
```
    ) -> Result<bool, Self::Error>;
```
[22.629546]
[22.629584]
```
    ) -> Result<bool, TxnErr<Self::GraphError>>;
}
```
Insertion in libpijul/src/pristine/mod.rs at line 1319 [22.586748]
[22.629585]
[22.629585]
```
pub trait ChannelMutTxnT: ChannelTxnT + GraphMutTxnT {
```
Replacement in libpijul/src/pristine/mod.rs at line 1327 [22.586748]
B:BD[22.629939] → [23.17988:18034]
```
    ) -> Result<Option<Merkle>, Self::Error>;
```
[22.629939]
[22.629987]
```
    ) -> Result<Option<Merkle>, TxnErr<Self::GraphError>>;
```

Replacement in libpijul/src/pristine/mod.rs at line 1335 [22.586748]

B:BD[22.630240] → [23.18035:18071]

    ) -> Result<bool, Self::Error>;

[22.630240]

[22.630278]

    ) -> Result<bool, TxnErr<Self::GraphError>>;
}
pub trait DepsMutTxnT: DepsTxnT {
    put_del!(dep, ChangeId, ChangeId, DepsError);
    put_del!(revdep, ChangeId, ChangeId, DepsError);
    put_del!(touched_files, Position<ChangeId>, ChangeId, DepsError);
    put_del!(rev_touched_files, ChangeId, Position<ChangeId>, DepsError);
}
pub trait TreeMutTxnT: TreeTxnT {
    put_del!(inodes, Inode, Position<ChangeId>, TreeError);
    put_del!(revinodes, Position<ChangeId>, Inode, TreeError);
    put_del!(tree, PathId, Inode, TreeError);
    put_del!(revtree, Inode, PathId, TreeError);
    fn put_partials(
        &mut self,
        k: &str,
        e: Position<ChangeId>,
    ) -> Result<bool, TxnErr<Self::TreeError>>;
    fn del_partials(
        &mut self,
        k: &str,
        e: Option<Position<ChangeId>>,
    ) -> Result<bool, TxnErr<Self::TreeError>>;
}

Insertion in libpijul/src/pristine/mod.rs at line 1363 [22.586748]

[22.630279]

/// The trait of immutable transactions.
pub trait MutTxnT:
    GraphMutTxnT
    + ChannelMutTxnT
    + DepsMutTxnT<DepsError = <Self as GraphTxnT>::GraphError>
    + TreeMutTxnT<TreeError = <Self as GraphTxnT>::GraphError>
    + TxnT
{

Replacement in libpijul/src/pristine/mod.rs at line 1381 [22.586748]

B:BD[22.631045] → [23.18072:18167]

    fn open_or_create_channel(&mut self, name: &str) -> Result<ChannelRef<Self>, Self::Error>;

[22.631045]

[22.631142]

    fn open_or_create_channel(&mut self, name: &str) -> Result<ChannelRef<Self>, Self::GraphError>;

Replacement in libpijul/src/pristine/mod.rs at line 1387 [22.586748]

B:BD[22.631231] → [23.18168:18227]

    ) -> Result<ChannelRef<Self>, ForkError<Self::Error>>;

[22.631231]

[22.631281]

    ) -> Result<ChannelRef<Self>, ForkError<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 1393 [22.586748]
B:BD[22.631384] → [23.18228:18273]
```
    ) -> Result<(), ForkError<Self::Error>>;
```
[22.631384]
[22.631420]
```
    ) -> Result<(), ForkError<Self::GraphError>>;
```

Replacement in libpijul/src/pristine/mod.rs at line 1395 [22.586748]

B:BD[22.631421] → [23.18274:18347]

    fn drop_channel(&mut self, name: &str) -> Result<bool, Self::Error>;

[22.631421]

[22.631496]

    fn drop_channel(&mut self, name: &str) -> Result<bool, Self::GraphError>;

Replacement in libpijul/src/pristine/mod.rs at line 1398 [22.586748]
B:BD[22.631530] → [23.18348:18396]
∅:D[23.18396] → [22.636462:636463]
B:BD[22.636462] → [22.636462:636463]
B:BD[22.636463] → [23.18397:18490]
```
    fn commit(self) -> Result<(), Self::Error>;
    fn put_partials(&mut self, k: &str, e: Position<ChangeId>) -> Result<bool, Self::Error>;
```
[22.631530]
[22.637989]
```
    fn commit(self) -> Result<(), Self::GraphError>;
```

Replacement in libpijul/src/pristine/mod.rs at line 1400 [22.586748]

B:BD[22.637990] → [23.18491:18600]

    fn del_partials(&mut self, k: &str, e: Option<Position<ChangeId>>)
        -> Result<bool, Self::Error>;

[22.637990]

[22.638143]

    fn open_or_create_remote(&mut self, name: &str) -> Result<RemoteRef<Self>, Self::GraphError>;

Deletion in libpijul/src/pristine/mod.rs at line 1402 [22.586748]
B:BD[22.638144] → [23.18601:18694]
∅:D[23.18694] → [22.638239:638240]
B:BD[22.638239] → [22.638239:638240]
```
    fn open_or_create_remote(&mut self, name: &str) -> Result<RemoteRef<Self>, Self::Error>;
```
Replacement in libpijul/src/pristine/mod.rs at line 1407 [22.586748]
B:BD[22.638359] → [23.18695:18731]
```
    ) -> Result<bool, Self::Error>;
```
[22.638359]
[22.638397]
```
    ) -> Result<bool, Self::GraphError>;
```

Replacement in libpijul/src/pristine/mod.rs at line 1409 [22.586748]

B:BD[22.638398] → [23.18732:18829]

    fn del_remote(&mut self, remote: &mut RemoteRef<Self>, k: u64) -> Result<bool, Self::Error>;

[22.638398]

[22.638497]

    fn del_remote(
        &mut self,
        remote: &mut RemoteRef<Self>,
        k: u64,
    ) -> Result<bool, Self::GraphError>;

Replacement in libpijul/src/pristine/mod.rs at line 1415 [22.586748]

B:BD[22.638498] → [23.18830:18915]

    fn drop_remote(&mut self, remote: RemoteRef<Self>) -> Result<bool, Self::Error>;

[22.638498]

[22.638585]

    fn drop_remote(&mut self, remote: RemoteRef<Self>) -> Result<bool, Self::GraphError>;

Replacement in libpijul/src/pristine/mod.rs at line 1417 [22.586748]

B:BD[22.638586] → [23.18916:18996]

    fn drop_named_remote(&mut self, remote: &str) -> Result<bool, Self::Error>;

[22.638586]

[26.50088]

    fn drop_named_remote(&mut self, remote: &str) -> Result<bool, Self::GraphError>;

Replacement in libpijul/src/pristine/mod.rs at line 1420 [22.586748]
B:BD[26.50091] → [26.50091:50138]
```
pub(crate) fn put_inodes_with_rev<T: MutTxnT>(
```
[26.50091]
[26.50138]
```
pub(crate) fn put_inodes_with_rev<T: TreeMutTxnT>(
```
Replacement in libpijul/src/pristine/mod.rs at line 1424 [22.586748]
B:BD[26.50207] → [23.18997:19025]
```
) -> Result<(), T::Error> {
```
[26.50207]
[26.50240]
```
) -> Result<(), TxnErr<T::TreeError>> {
```
Replacement in libpijul/src/pristine/mod.rs at line 1430 [22.586748]
B:BD[41.1530] → [41.1530:1577]
```
pub(crate) fn del_inodes_with_rev<T: MutTxnT>(
```
[41.1530]
[41.1577]
```
pub(crate) fn del_inodes_with_rev<T: TreeMutTxnT>(
```
Replacement in libpijul/src/pristine/mod.rs at line 1434 [22.586748]
B:BD[41.1646] → [23.19026:19056]
```
) -> Result<bool, T::Error> {
```
[41.1646]
[41.1681]
```
) -> Result<bool, TxnErr<T::TreeError>> {
```
Replacement in libpijul/src/pristine/mod.rs at line 1443 [22.586748]
B:BD[41.1846] → [41.1846:1891]
```
pub(crate) fn put_tree_with_rev<T: MutTxnT>(
```
[41.1846]
[41.1891]
```
pub(crate) fn put_tree_with_rev<T: TreeMutTxnT>(
```
Replacement in libpijul/src/pristine/mod.rs at line 1447 [22.586748]
B:BD[41.1947] → [23.19057:19085]
```
) -> Result<(), T::Error> {
```
[41.1947]
[41.1980]
```
) -> Result<(), TxnErr<T::TreeError>> {
```
Replacement in libpijul/src/pristine/mod.rs at line 1453 [22.586748]
B:BD[26.50333] → [41.2054:2099]
```
pub(crate) fn del_tree_with_rev<T: MutTxnT>(
```
[26.50333]
[41.2099]
```
pub(crate) fn del_tree_with_rev<T: TreeMutTxnT>(
```
Replacement in libpijul/src/pristine/mod.rs at line 1457 [22.586748]
B:BD[41.2155] → [23.19086:19116]
```
) -> Result<bool, T::Error> {
```
[41.2155]
[41.2190]
```
) -> Result<bool, TxnErr<T::TreeError>> {
```
Replacement in libpijul/src/pristine/mod.rs at line 1470 [22.586748]
B:BD[26.50444] → [26.50444:50483]
```
pub(crate) fn split_block<T: MutTxnT>(
```
[26.50444]
[26.50483]
```
pub(crate) fn split_block<T: GraphMutTxnT>(
```
Replacement in libpijul/src/pristine/mod.rs at line 1472 [22.586748]
B:BD[26.50500] → [26.50500:50530]
```
    channel: &mut Channel<T>,
```
[26.50500]
[26.50530]
```
    graph: &mut T::Graph,
```

Replacement in libpijul/src/pristine/mod.rs at line 1475 [22.586748]

B:BD[26.50582] → [23.19117:19145]

∅:D[23.19145] → [26.50615:50937]

B:BD[26.50615] → [26.50615:50937]

) -> Result<(), T::Error> {
    trace!("key = {:?}, pos = {:?}", key, pos);
    let adjacent: Vec<_> = txn
        .cursor_graph(&channel.graph, Some((key, None)))
        .take_while(|&(k, _)| k <= key)
        .filter(|&(k, _)| k == key)
        .map(|(_, e)| e)
        .collect();
    debug!("adjacent {:?}", adjacent);
    for chi in adjacent {

[26.50582]

[26.50937]

    buf: &mut Vec<Edge>,
) -> Result<(), TxnErr<T::GraphError>> {
    for x in txn.cursor_graph(graph, Some((key, None)))? {
        let (k, v) = x?;
        if k > key {
            break;
        } else if k < key {
            continue;
        }
        buf.push(v)
    }
    for chi in buf.drain(..) {

Replacement in libpijul/src/pristine/mod.rs at line 1491 [22.586748]
B:BD[26.51153] → [26.51153:51178]
```
                channel,
```
[26.51153]
[26.51178]
```
                graph,
```
Replacement in libpijul/src/pristine/mod.rs at line 1507 [22.586748]
B:BD[26.51588] → [26.51588:51648]
```
        txn.del_graph(&mut channel.graph, key, Some(chi))?;
```
[26.51588]
[26.51648]
```
        txn.del_graph(graph, key, Some(chi))?;
```
Replacement in libpijul/src/pristine/mod.rs at line 1509 [22.586748]
B:BD[26.51671] → [26.51671:51703]
```
            &mut channel.graph,
```
[26.51671]
[26.51703]
```
            graph,
```
Replacement in libpijul/src/pristine/mod.rs at line 1529 [22.586748]
B:BD[26.52142] → [26.52142:52188]
```
pub(crate) fn del_graph_with_rev<T: MutTxnT>(
```
[26.52142]
[26.52188]
```
pub(crate) fn del_graph_with_rev<T: GraphMutTxnT>(
```
Replacement in libpijul/src/pristine/mod.rs at line 1531 [22.586748]
B:BD[26.52205] → [26.52205:52235]
```
    channel: &mut Channel<T>,
```
[26.52205]
[26.52235]
```
    graph: &mut T::Graph,
```
Replacement in libpijul/src/pristine/mod.rs at line 1536 [22.586748]
B:BD[26.52349] → [23.19146:19176]
```
) -> Result<bool, T::Error> {
```
[26.52349]
[26.52384]
```
) -> Result<bool, TxnErr<T::GraphError>> {
```
Replacement in libpijul/src/pristine/mod.rs at line 1543 [22.586748]
B:BD[26.52598] → [26.52598:52626]
```
        &mut channel.graph,
```
[26.52598]
[26.52626]
```
        graph,
```
Replacement in libpijul/src/pristine/mod.rs at line 1555 [22.586748]
B:BD[26.52866] → [26.52866:52894]
```
        &mut channel.graph,
```
[26.52866]
[26.52894]
```
        graph,
```
Replacement in libpijul/src/pristine/mod.rs at line 1570 [22.586748]
B:BD[26.53180] → [26.53180:53226]
```
pub(crate) fn put_graph_with_rev<T: MutTxnT>(
```
[26.53180]
[26.53226]
```
pub(crate) fn put_graph_with_rev<T: GraphMutTxnT>(
```
Replacement in libpijul/src/pristine/mod.rs at line 1572 [22.586748]
B:BD[26.53243] → [26.53243:53273]
```
    channel: &mut Channel<T>,
```
[26.53243]
[26.53273]
```
    graph: &mut T::Graph,
```
Replacement in libpijul/src/pristine/mod.rs at line 1577 [22.586748]
B:BD[26.53375] → [23.19177:19207]
```
) -> Result<bool, T::Error> {
```
[26.53375]
[26.53410]
```
) -> Result<bool, TxnErr<T::GraphError>> {
```
Replacement in libpijul/src/pristine/mod.rs at line 1587 [22.586748]
B:BD[26.53742] → [26.53742:53770]
```
        &mut channel.graph,
```
[26.53742]
[26.53770]
```
        graph,
```
Replacement in libpijul/src/pristine/mod.rs at line 1599 [22.586748]
B:BD[26.54004] → [26.54004:54032]
```
        &mut channel.graph,
```
[26.54004]
[26.54032]
```
        graph,
```

Replacement in libpijul/src/pristine/mod.rs at line 1614 [22.586748]

B:BD[26.54311] → [26.54311:54354]

pub(crate) fn register_change<T: MutTxnT>(

[26.54311]

[26.54354]

pub(crate) fn register_change<
    T: GraphMutTxnT + DepsMutTxnT<DepsError = <T as GraphTxnT>::GraphError>,
>(

Replacement in libpijul/src/pristine/mod.rs at line 1621 [22.586748]
B:BD[26.54432] → [23.19208:19236]
```
) -> Result<(), T::Error> {
```
[26.54432]
[28.12106]
```
) -> Result<(), TxnErr<T::GraphError>> {
```
Replacement in libpijul/src/pristine/mod.rs at line 1627 [22.586748]
∅:D[28.12187] → [26.54658:54718]
B:BD[26.54658] → [26.54658:54718]
```
        let dep_internal = txn.get_internal(*dep).unwrap();
```
[28.12187]
[28.12188]
```
        let dep_internal = txn.get_internal(*dep)?.unwrap();
```

Insertion in libpijul/src/pristine/mod.rs at line 1649 [22.586748]

[26.55157]

        let change = if let Some(c) = inode.change {
            txn.get_internal(c)?.unwrap_or(internal)
        } else {
            internal
        };

Replacement in libpijul/src/pristine/mod.rs at line 1655 [22.586748]

B:BD[26.55188] → [26.55188:55337]

            change: inode
                .change
                .and_then(|change| txn.get_internal(change))
                .unwrap_or(internal),

[26.55188]

[26.55337]

            change,

Replacement in libpijul/src/pristine/mod.rs at line 1676 [22.586748]

B:BD[57.583] → [57.583:650]

pub fn check_tree_inodes<T: TxnT>(txn: &T, channel: &Channel<T>) {

[57.583]

[57.650]

pub fn check_tree_inodes<T: GraphTxnT + TreeTxnT>(txn: &T, channel: &T::Graph) {

Replacement in libpijul/src/pristine/mod.rs at line 1678 [22.586748]

B:BD[57.670] → [57.670:717]

    for (inode, vertex) in txn.iter_inodes() {

[57.670]

[57.717]

    for x in txn.iter_inodes().unwrap() {
        let (inode, vertex) = x.unwrap();

Replacement in libpijul/src/pristine/mod.rs at line 1682 [22.586748]

B:BD[57.783] → [57.783:847]

            if let Some(next) = txn.get_revtree(inode_, None) {

[57.783]

[57.847]

            if let Some(next) = txn.get_revtree(inode_, None).unwrap() {

Replacement in libpijul/src/pristine/mod.rs at line 1688 [22.586748]

B:BD[57.1006] → [57.1006:1067]

B:BD[57.1067] → [21.7742:7816]

∅:D[21.7816] → [57.1275:1334]

B:BD[57.1275] → [57.1275:1334]

        if !is_alive(txn, &channel, vertex.inode_vertex()) {
            for e in iter_adj_all(txn, &channel, vertex.inode_vertex()) {
                error!("{:?} {:?} {:?}", inode, vertex, e)

[57.1006]

[57.1334]

        if !is_alive(txn, &channel, vertex.inode_vertex()).unwrap() {
            for e in iter_adj_all(txn, channel, vertex.inode_vertex()).unwrap() {
                error!("{:?} {:?} {:?}", inode, vertex, e.unwrap())

Replacement in libpijul/src/pristine/mod.rs at line 1705 [22.586748]

B:BD[57.1708] → [57.1708:1758]

    for (id, inode) in txn.iter_tree(id0, None) {

[57.1708]

[57.1758]

    for x in txn.iter_tree(id0, None).unwrap() {
        let (id, inode) = x.unwrap();

Replacement in libpijul/src/pristine/mod.rs at line 1714 [22.586748]

B:BD[57.1993] → [57.1993:2064]

pub fn check_alive_debug<T: TxnT, C: crate::changestore::ChangeStore>(

[57.1993]

[57.2064]

pub fn check_alive_debug<T: ChannelTxnT, C: crate::changestore::ChangeStore>(

Replacement in libpijul/src/pristine/mod.rs at line 1717 [22.586748]
B:BD[57.2094] → [57.2094:2123]
```
    channel: &ChannelRef<T>,
```
[57.2094]
[57.2123]
```
    channel: &Channel<T>,
```

Replacement in libpijul/src/pristine/mod.rs at line 1720 [22.586748]

∅:D[23.19271] → [57.2171:2245]

B:BD[57.2171] → [57.2171:2245]

    let (alive, reachable) = crate::pristine::check_alive(txn, &channel);

[23.19271]

[57.2245]

    let (alive, reachable) = crate::pristine::check_alive(txn, &channel.graph);

Replacement in libpijul/src/pristine/mod.rs at line 1737 [22.586748]

B:BD[43.489] → [43.489:590]

        let (path, _) = crate::fs::find_path(changes, txn, &channel.borrow(), true, file_).unwrap();

[43.489]

[43.590]

        let (path, _) = crate::fs::find_path(changes, txn, channel, true, file_).unwrap();

Replacement in libpijul/src/pristine/mod.rs at line 1746 [22.586748]

∅:D[43.835] → [57.2776:2938]

B:BD[57.2776] → [57.2776:2938]

        let graph = crate::alive::retrieve::retrieve(txn, &channel.borrow(), file_);
        graph.debug(changes, txn, &channel.borrow(), false, false, &mut f)?;

[43.835]

[57.2938]

        let graph = crate::alive::retrieve::retrieve(txn, &channel.graph, file_).unwrap();
        graph.debug(changes, txn, &channel.graph, false, false, &mut f)?;

Replacement in libpijul/src/pristine/mod.rs at line 1750 [22.586748]

∅:D[43.906] → [57.3018:3058]

B:BD[57.3018] → [57.3018:3058]

B:BD[57.3058] → [42.806:872]

        let channel = channel.borrow();
        debug_root(txn, &channel, file.unwrap(), &mut f, false)?;

[43.906]

[57.3117]

        debug_root(txn, &channel.graph, file.unwrap(), &mut f, false)?;

Insertion in libpijul/src/pristine/channel_dump.rs at line 10 [22.650052]

[23.19475]

}
impl<T: std::error::Error + 'static> std::convert::From<TxnErr<T>> for ChannelDumpError<T> {
    fn from(e: TxnErr<T>) -> Self {
        ChannelDumpError::Txn(e.0)
    }

Replacement in libpijul/src/pristine/channel_dump.rs at line 18 [22.650052]

B:BD[22.650094] → [22.650094:650167]

enum DumpChannelState<T: super::TxnT, RT: std::ops::Deref<Target = T>> {

[22.650094]

[22.650167]

enum DumpChannelState<
    T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
    RT: std::ops::Deref<Target = T>,
> {

Replacement in libpijul/src/pristine/channel_dump.rs at line 35 [22.650052]
B:BD[22.650588] → [22.650588:650608]
```
    T: super::TxnT,
```
[22.650588]
[22.650608]
```
    T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
```
Replacement in libpijul/src/pristine/channel_dump.rs at line 71 [22.650052]
B:BD[22.651272] → [22.651272:651296]
```
        T: super::TxnT,
```
[22.651272]
[22.651296]
```
        T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
```
Replacement in libpijul/src/pristine/channel_dump.rs at line 76 [22.650052]
B:BD[22.651454] → [22.651454:651481]
```
    type Item = DumpChunk;
```
[22.651454]
[22.651481]
```
    type Item = Result<DumpChunk, TxnErr<T::GraphError>>;
```

Replacement in libpijul/src/pristine/channel_dump.rs at line 86 [22.650052]

B:BD[22.651789] → [22.651789:651854]

                        while let Some((h, dep)) = deps.next() {

[22.651789]

[22.651854]

                        while let Some(x) = deps.next() {
                            let (h, dep) = match x {
                                Ok(x) => x,
                                Err(e) => return Some(Err(e)),
                            };

Replacement in libpijul/src/pristine/channel_dump.rs at line 104 [22.650052]

B:BD[22.652501] → [22.652501:652563]

                            return Some(DumpChunk::Dep(msg));

[22.652501]

[22.652563]

                            return Some(Ok(DumpChunk::Dep(msg)));

Replacement in libpijul/src/pristine/channel_dump.rs at line 107 [22.650052]

B:BD[22.652611] → [22.652611:652750]

                    if let Some((_, (h, _))) = log.next() {
                        let deps = Some(T::iter_dep_ref(self.txn.clone(), h));

[22.652611]

[22.652750]

                    if let Some(x) = log.next() {
                        let (_, (h, _)) = match x {
                            Ok(e) => e,
                            Err(e) => return Some(Err(e)),
                        };
                        let deps = match T::iter_dep_ref(self.txn.clone(), h) {
                            Ok(e) => Some(e),
                            Err(e) => return Some(Err(e)),
                        };

Replacement in libpijul/src/pristine/channel_dump.rs at line 121 [22.650052]

B:BD[22.652955] → [22.652955:653024]

                        let ext = self.txn.get_external(h).unwrap();

[22.652955]

[22.653024]

                        let ext = match self.txn.get_external(h) {
                            Ok(ext) => ext.unwrap(),
                            Err(e) => return Some(Err(e)),
                        };

Replacement in libpijul/src/pristine/channel_dump.rs at line 129 [22.650052]

B:BD[22.653253] → [22.653253:653312]

                        return Some(DumpChunk::Hash(msg));

[22.653253]

[22.653312]

                        return Some(Ok(DumpChunk::Hash(msg)));

Replacement in libpijul/src/pristine/channel_dump.rs at line 132 [22.650052]

B:BD[22.653409] → [26.55589:55640]

                            graph: iter_graph_ref(

[22.653409]

[22.653463]

                            graph: match iter_graph_ref(

Replacement in libpijul/src/pristine/channel_dump.rs at line 137 [22.650052]

B:BD[22.653650] → [22.653650:653681]

),

[22.653650]

[22.653681]

                            ) {
                                Ok(x) => x,
                                Err(e) => return Some(Err(e)),
                            },

Replacement in libpijul/src/pristine/channel_dump.rs at line 151 [22.650052]

B:BD[22.654008] → [22.654008:654065]

                    if let Some((v, e)) = graph.next() {

[22.654008]

[22.654065]

                    if let Some(x) = graph.next() {
                        let (v, e) = match x {
                            Err(e) => return Some(Err(e)),
                            Ok(x) => x,
                        };

Replacement in libpijul/src/pristine/channel_dump.rs at line 180 [22.650052]

B:BD[22.655490] → [22.655490:655553]

                            return Some(DumpChunk::Edge(buf));

[22.655490]

[22.655553]

                            return Some(Ok(DumpChunk::Edge(buf)));

Replacement in libpijul/src/pristine/channel_dump.rs at line 193 [22.650052]

B:BD[22.656272] → [22.656272:656334]

                            return Some(DumpChunk::End(buf));

[22.656272]

[22.656334]

                            return Some(Ok(DumpChunk::End(buf)));

Replacement in libpijul/src/pristine/channel_dump.rs at line 202 [22.650052]

B:BD[22.656845] → [22.656845:656903]

                        return Some(DumpChunk::End(buf));

[22.656845]

[22.656903]

                        return Some(Ok(DumpChunk::End(buf)));

Replacement in libpijul/src/pristine/channel_dump.rs at line 212 [22.650052]
B:BD[22.657034] → [22.657034:657054]
```
    T: super::TxnT,
```
[22.657034]
[22.657054]
```
    T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
```
Replacement in libpijul/src/pristine/channel_dump.rs at line 218 [22.650052]
B:BD[22.657193] → [22.657193:657240]
```
) -> DumpChannel<T, RT, C> {
    DumpChannel {
```
[22.657193]
[22.657240]
```
) -> Result<DumpChannel<T, RT, C>, TxnErr<T::GraphError>> {
    Ok(DumpChannel {
```

Replacement in libpijul/src/pristine/channel_dump.rs at line 221 [22.650052]

B:BD[22.657288] → [26.55641:55702]

            log: changeid_log_ref(txn.clone(), &channel, 0),

[22.657288]

[22.657352]

            log: changeid_log_ref(txn.clone(), &channel, 0)?,

Replacement in libpijul/src/pristine/channel_dump.rs at line 227 [22.650052]
B:BD[22.657455] → [22.657455:657461]
```
    }
```
[22.657455]
[22.657461]
```
    })
```
Replacement in libpijul/src/pristine/channel_dump.rs at line 230 [22.650052]
B:BD[22.657464] → [22.657464:657516]
```
pub struct ChannelFromDump<'a, T: super::MutTxnT> {
```
[22.657464]
[22.657516]
```
pub struct ChannelFromDump<'a, T: ChannelMutTxnT> {
```

Replacement in libpijul/src/pristine/channel_dump.rs at line 322 [22.650052]

B:BD[22.660741] → [22.660741:660794]

impl<'a, T: super::MutTxnT> ChannelFromDump<'a, T> {

[22.660741]

[22.660794]

impl<'a, T: ChannelMutTxnT + DepsMutTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>>
    ChannelFromDump<'a, T>
{

Replacement in libpijul/src/pristine/channel_dump.rs at line 341 [22.650052]

B:BD[22.661301] → [23.19478:19547]

    pub fn read(&mut self, bytes: &[u8]) -> Result<bool, T::Error> {

[22.661301]

[22.661375]

    pub fn read(&mut self, bytes: &[u8]) -> Result<bool, TxnErr<T::GraphError>> {

Replacement in libpijul/src/pristine/channel_dump.rs at line 350 [22.650052]

B:BD[22.661853] → [22.661853:661918]

                    if let Some(hh) = self.txn.get_external(p) {

[22.661853]

[22.661918]

                    if let Some(hh) = self.txn.get_external(p)? {

Replacement in libpijul/src/pristine/channel_dump.rs at line 352 [22.650052]

B:BD[22.661958] → [26.55703:55772]

                            let pp = make_changeid(self.txn, &hash);

[22.661958]

[22.662026]

                            let pp = make_changeid(self.txn, &hash)?;

Replacement in libpijul/src/pristine/channel_dump.rs at line 422 [22.650052]
B:BD[22.664926] → [22.664926:664964]
```
fn finish_channel<T: super::MutTxnT>(
```
[22.664926]
[22.664964]
```
fn finish_channel<T: super::ChannelMutTxnT>(
```
Replacement in libpijul/src/pristine/channel_dump.rs at line 427 [22.650052]
B:BD[22.665110] → [23.19548:19576]
```
) -> Result<(), T::Error> {
```
[22.665110]
[22.665143]
```
) -> Result<(), TxnErr<T::GraphError>> {
```

Replacement in libpijul/src/pristine/block.rs at line 4 [58.11]

B:BD[23.19602] → [23.19602:19694]

#[error("Block error: {:?}", block)]
pub struct BlockError {
    block: Position<ChangeId>,

[23.19602]

[23.19694]

pub enum BlockError<T: std::error::Error + 'static> {
    #[error(transparent)]
    Txn(T),
    #[error("Block error: {:?}", block)]
    Block { block: Position<ChangeId> },
}
impl<T: std::error::Error + 'static> std::convert::From<TxnErr<T>> for BlockError<T> {
    fn from(e: TxnErr<T>) -> Self {
        BlockError::Txn(e.0)
    }

Replacement in libpijul/src/pristine/block.rs at line 18 [58.11]

B:BD[58.65] → [58.65:116]

pub(crate) fn find_block<'db, 'txn: 'db, T: TxnT>(

[58.65]

[58.116]

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

Replacement in libpijul/src/pristine/block.rs at line 20 [58.11]
B:BD[58.134] → [58.134:164]
```
    channel: &'db Channel<T>,
```
[58.134]
[58.164]
```
    graph: &'db T::Graph,
```
Replacement in libpijul/src/pristine/block.rs at line 22 [58.11]
B:BD[58.191] → [23.19697:19741]
```
) -> Result<Vertex<ChangeId>, BlockError> {
```
[58.191]
[58.237]
```
) -> Result<Vertex<ChangeId>, BlockError<T::GraphError>> {
```

Replacement in libpijul/src/pristine/block.rs at line 32 [58.11]

B:BD[58.470] → [58.470:608]

    let mut cursor = txn.cursor_graph(&channel.graph, Some((key, None)));
    let mut k = if let Some((k, _)) = cursor.next() {
        k

[58.470]

[58.608]

    let mut cursor = txn.cursor_graph(graph, Some((key, None)))?;
    let mut k = if let Some(k) = cursor.next() {
        k?.0

Replacement in libpijul/src/pristine/block.rs at line 36 [58.11]
B:BD[58.621] → [23.19742:19787]
```
        return Err(BlockError { block: p });
```
[58.621]
[58.680]
```
        return Err(BlockError::Block { block: p });
```

Replacement in libpijul/src/pristine/block.rs at line 45 [58.11]

B:BD[58.1113] → [58.1113:1179]

        if let Some((k_, _)) = cursor.prev() {
            k = k_

[58.1113]

[58.1179]

        if let Some(k_) = cursor.prev() {
            k = k_?.0

Replacement in libpijul/src/pristine/block.rs at line 58 [58.11]

B:BD[58.1526] → [23.19788:19837]

            return Err(BlockError { block: p });

[58.1526]

[58.1589]

            return Err(BlockError::Block { block: p });

Replacement in libpijul/src/pristine/block.rs at line 60 [58.11]

B:BD[58.1599] → [58.1599:1665]

        if let Some((k_, _)) = cursor.next() {
            k = k_

[58.1599]

[58.1665]

        if let Some(k_) = cursor.next() {
            k = k_?.0

Replacement in libpijul/src/pristine/block.rs at line 67 [58.11]
B:BD[58.1789] → [23.19838:19871]
```
    Err(BlockError { block: p })
```
[58.1789]
[58.1836]
```
    Err(BlockError::Block { block: p })
```

Replacement in libpijul/src/pristine/block.rs at line 71 [58.11]

B:BD[58.1878] → [58.1878:1933]

pub(crate) fn find_block_end<'db, 'txn: 'db, T: TxnT>(

[58.1878]

[58.1933]

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

Replacement in libpijul/src/pristine/block.rs at line 73 [58.11]
B:BD[58.1951] → [58.1951:1981]
```
    channel: &'db Channel<T>,
```
[58.1951]
[58.1981]
```
    graph: &'db T::Graph,
```
Replacement in libpijul/src/pristine/block.rs at line 75 [58.11]
B:BD[58.2008] → [23.19872:19916]
```
) -> Result<Vertex<ChangeId>, BlockError> {
```
[58.2008]
[58.2054]
```
) -> Result<Vertex<ChangeId>, BlockError<T::GraphError>> {
```

Replacement in libpijul/src/pristine/block.rs at line 85 [58.11]

B:BD[58.2326] → [58.2326:2464]

    let mut cursor = txn.cursor_graph(&channel.graph, Some((key, None)));
    let mut k = if let Some((k, _)) = cursor.next() {
        k

[58.2326]

[58.2464]

    let mut cursor = txn.cursor_graph(graph, Some((key, None)))?;
    let mut k = if let Some(k) = cursor.next() {
        k?.0

Replacement in libpijul/src/pristine/block.rs at line 89 [58.11]
B:BD[58.2477] → [23.19917:19962]
```
        return Err(BlockError { block: p });
```
[58.2477]
[58.2536]
```
        return Err(BlockError::Block { block: p });
```

Replacement in libpijul/src/pristine/block.rs at line 106 [58.11]

B:BD[58.3253] → [58.3253:3319]

        if let Some((k_, _)) = cursor.prev() {
            k = k_

[58.3253]

[58.3319]

        if let Some(k_) = cursor.prev() {
            k = k_?.0

Replacement in libpijul/src/pristine/block.rs at line 116 [58.11]

B:BD[58.3643] → [58.3643:3709]

        if let Some((k_, _)) = cursor.next() {
            k = k_

[58.3643]

[58.3709]

        if let Some(k_) = cursor.next() {
            k = k_?.0

Replacement in libpijul/src/pristine/block.rs at line 126 [58.11]
B:BD[58.3968] → [23.19963:20000]
```
        Err(BlockError { block: p })
```
[58.3968]
[58.4019]
```
        Err(BlockError::Block { block: p })
```

Replacement in libpijul/src/output/output.rs at line 37 [22.671807]

B:BD[22.673225] → [23.20081:20153]

) -> Result<Vec<Conflict>, OutputError<P::Error, T::Error, R::Error>> {

[22.673225]

[22.673269]

) -> Result<Vec<Conflict>, OutputError<P::Error, T::GraphError, R::Error>> {

Replacement in libpijul/src/output/output.rs at line 51 [22.671807]
B:BD[22.673568] → [22.673568:673584]
```
    T: MutTxnT,
```
[22.673568]
[22.673584]
```
    T: TreeMutTxnT + ChannelTxnT + GraphMutTxnT<GraphError = <T as TreeTxnT>::TreeError>,
```

Replacement in libpijul/src/output/output.rs at line 63 [22.671807]

B:BD[22.673828] → [23.20154:20226]

) -> Result<Vec<Conflict>, OutputError<P::Error, T::Error, R::Error>> {

[22.673828]

[22.673931]

) -> Result<Vec<Conflict>, OutputError<P::Error, T::TreeError, R::Error>> {

Replacement in libpijul/src/output/output.rs at line 71 [22.671807]
B:BD[22.674146] → [22.674146:674163]
```
        channel,
```
[22.674146]
[22.674163]
```
        &channel.graph,
```

Replacement in libpijul/src/output/output.rs at line 80 [22.671807]

B:BD[22.674352] → [22.674352:674437]

        let dead = collect_dead_files(txn, channel, pending_change_id, Inode::ROOT);

[22.674352]

[22.674437]

        let dead = collect_dead_files(txn, &channel.graph, pending_change_id, Inode::ROOT)?;

Replacement in libpijul/src/output/output.rs at line 122 [22.671807]

B:BD[22.676154] → [22.676154:676216]

                if let Some((inode, _)) = output_item.inode {

[22.676154]

[22.676216]


                let output_item_inode =
                    if let Some(inode) = txn.get_revinodes(output_item.pos, None)? {
                        Some((inode, txn.get_inodes(inode, None)?.unwrap()))
                    } else {
                        None
                    };
                if let Some((inode, _)) = output_item_inode {

Insertion in libpijul/src/output/output.rs at line 159 [22.671807]
[22.677510]
[22.677510]
```
                    output_item_inode,
```

Replacement in libpijul/src/output/output.rs at line 165 [22.671807]

B:BD[22.677697] → [22.677697:677788]

                    let dead = collect_dead_files(txn, channel, pending_change_id, inode);

[22.677697]

[22.677788]

                    let dead = collect_dead_files(txn, &channel.graph, pending_change_id, inode)?;

Replacement in libpijul/src/output/output.rs at line 176 [22.671807]
B:BD[22.678240] → [22.678240:678273]
```
                        channel,
```
[22.678240]
[22.678273]
```
                        &channel.graph,
```
Replacement in libpijul/src/output/output.rs at line 182 [22.671807]
B:BD[22.678463] → [22.678463:678486]
```
                    )?
```
[22.678463]
[22.678486]
```
                    )?;
```

Replacement in libpijul/src/output/output.rs at line 224 [22.671807]

B:BD[23.21084] → [23.21084:21147]

fn move_or_create<T: MutTxnT, R: WorkingCopy, C: ChangeStore>(

[23.21084]

[22.679732]

fn move_or_create<T: TreeMutTxnT, R: WorkingCopy, C: ChangeStore>(

Insertion in libpijul/src/output/output.rs at line 228 [22.671807]
[22.679797]
[22.679797]
```
    output_item_inode: Option<(Inode, Position<ChangeId>)>,
```

Replacement in libpijul/src/output/output.rs at line 232 [22.671807]

B:BD[22.679880] → [23.21148:21212]

) -> Result<Inode, OutputError<C::Error, T::Error, R::Error>> {

[22.679880]

[22.679916]

) -> Result<Inode, OutputError<C::Error, T::TreeError, R::Error>> {

Replacement in libpijul/src/output/output.rs at line 240 [22.671807]
∅:D[23.21214] → [22.680195:680245]
B:BD[22.680195] → [22.680195:680245]
```
    if let Some((inode, _)) = output_item.inode {
```
[23.21214]
[22.680245]
```
    if let Some((inode, _)) = output_item_inode {
```

Replacement in libpijul/src/output/output.rs at line 244 [22.671807]

B:BD[22.680369] → [22.680369:680438]

        if let Some(ref current_name) = inode_filename(txn, inode) {

[22.680369]

[22.680438]

        if let Some(ref current_name) = inode_filename(txn, inode)? {

Replacement in libpijul/src/output/output.rs at line 247 [22.671807]

B:BD[22.680552] → [22.680552:680631]

                let parent = txn.get_revtree(inode, None).unwrap().to_owned();

[22.680552]

[22.680631]

                let parent = txn.get_revtree(inode, None)?.unwrap().to_owned();

Replacement in libpijul/src/output/output.rs at line 249 [22.671807]

B:BD[22.680701] → [23.21215:21339]

                del_tree_with_rev(txn, parent.as_file_id(), inode)
                    .map_err(PristineOutputError::Txn)?;

[22.680701]

[22.680852]

                del_tree_with_rev(txn, parent.as_file_id(), inode)?;

Replacement in libpijul/src/output/output.rs at line 267 [22.671807]

B:BD[22.681455] → [22.681455:681523]

                if let Some(inode) = txn.get_tree(file_id_, None) {

[22.681455]

[13.0]

                if let Some(inode) = txn.get_tree(file_id_, None)? {

Replacement in libpijul/src/output/output.rs at line 271 [22.671807]

B:BD[22.681620] → [23.21590:21804]

                put_inodes_with_rev(txn, inode, output_item.pos)
                    .map_err(PristineOutputError::Txn)?;
                put_tree_with_rev(txn, file_id_, inode).map_err(PristineOutputError::Txn)?;

[22.681620]

[22.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 276 [22.671807]

B:BD[22.681944] → [22.681944:682008]

            if let Some(inode) = txn.get_tree(file_id_, None) {

[22.681944]

[13.72]

            if let Some(inode) = txn.get_tree(file_id_, None)? {

Replacement in libpijul/src/output/output.rs at line 280 [22.671807]

B:BD[22.682097] → [23.21935:22120]

            put_inodes_with_rev(txn, inode, output_item.pos).map_err(PristineOutputError::Txn)?;
            put_tree_with_rev(txn, file_id_, inode).map_err(PristineOutputError::Txn)?;

[22.682097]

[22.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 285 [22.671807]

B:BD[22.682397] → [22.682397:682457]

        if let Some(inode) = txn.get_tree(file_id_, None) {

[22.682397]

[13.140]

        if let Some(inode) = txn.get_tree(file_id_, None)? {

Replacement in libpijul/src/output/output.rs at line 288 [22.671807]
B:BD[22.682538] → [22.682538:682581]
```
        let inode = create_new_inode(txn);
```
[22.682538]
[22.682581]
```
        let inode = create_new_inode(txn)?;
```

Replacement in libpijul/src/output/output.rs at line 293 [22.671807]

B:BD[22.682701] → [23.22243:22420]

        put_inodes_with_rev(txn, inode, output_item.pos).map_err(PristineOutputError::Txn)?;
        put_tree_with_rev(txn, file_id_, inode).map_err(PristineOutputError::Txn)?;

[22.682701]

[13.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 300 [22.671807]

B:BD[13.416] → [13.416:523]

            txn.put_tree(path_id.as_file_id(), inode)
                .map_err(PristineOutputError::Txn)?;

[13.416]

[13.523]

            txn.put_tree(path_id.as_file_id(), inode)?;

Replacement in libpijul/src/output/output.rs at line 306 [22.671807]

B:BD[23.22422] → [23.22422:22482]

fn output_file<T: MutTxnT, P: ChangeStore, W: WorkingCopy>(

[23.22422]

[22.683010]

fn output_file<T: ChannelTxnT + GraphMutTxnT, P: ChangeStore, W: WorkingCopy>(

Replacement in libpijul/src/output/output.rs at line 313 [22.671807]

B:BD[22.683171] → [23.22483:22544]

∅:D[23.22544] → [22.683204:683261]

B:BD[22.683204] → [22.683204:683261]

) -> Result<(), OutputError<P::Error, T::Error, W::Error>> {
    let mut l = retrieve(txn, channel, output_item.pos);

[22.683171]

[22.683261]

) -> Result<(), OutputError<P::Error, T::GraphError, W::Error>> {
    let mut l = retrieve(txn, &channel.graph, output_item.pos)?;

Replacement in libpijul/src/output/output.rs at line 321 [22.671807]

B:BD[22.683557] → [26.55773:55839]

        let dest = find_block(txn, &channel, edge.dest).unwrap();

[22.683557]

[22.683622]

        let dest = find_block(txn, &channel.graph, edge.dest).unwrap();

Replacement in libpijul/src/output/output.rs at line 323 [22.671807]

B:BD[22.683698] → [23.22669:22804]

        del_graph_with_rev(txn, channel, edge.flag, vertex, dest, edge.introduced_by)
            .map_err(PristineOutputError::Txn)?;

[22.683698]

[22.683785]

        del_graph_with_rev(
            txn,
            &mut channel.graph,
            edge.flag,
            vertex,
            dest,
            edge.introduced_by,
        )?;

Replacement in libpijul/src/output/output.rs at line 335 [22.671807]
∅:D[23.22806] → [22.683859:683894]
B:BD[22.683859] → [22.683859:683894]
```
fn collect_dead_files<T: MutTxnT>(
```
[23.22806]
[22.683894]
```
fn collect_dead_files<T: TreeMutTxnT + GraphTxnT<GraphError = <T as TreeTxnT>::TreeError>>(
```
Replacement in libpijul/src/output/output.rs at line 337 [22.671807]
B:BD[22.683911] → [22.683911:683937]
```
    channel: &Channel<T>,
```
[22.683911]
[22.683937]
```
    channel: &T::Graph,
```

Replacement in libpijul/src/output/output.rs at line 340 [22.671807]

B:BD[22.683988] → [22.683988:684041]

) -> HashMap<OwnedPathId, (Inode, Option<String>)> {

[22.683988]

[22.684041]

) -> Result<HashMap<OwnedPathId, (Inode, Option<String>)>, TxnErr<T::GraphError>> {

Replacement in libpijul/src/output/output.rs at line 346 [22.671807]
B:BD[22.684246] → [22.684246:684293]
```
            for (id, inode_) in txn.iter_tree(
```
[22.684246]
[22.684293]
```
            for x in txn.iter_tree(
```
Replacement in libpijul/src/output/output.rs at line 352 [22.671807]
B:BD[22.684462] → [22.684462:684478]
```
            ) {
```
[22.684462]
[22.684478]
```
            )? {
                let (id, inode_) = x?;
```

Replacement in libpijul/src/output/output.rs at line 360 [22.671807]

B:BD[22.684700] → [22.684700:684773]

                    if let Some(vertex) = txn.get_inodes(inode_, None) {

[22.684700]

[22.684773]

                    if let Some(vertex) = txn.get_inodes(inode_, None)? {

Replacement in libpijul/src/output/output.rs at line 362 [22.671807]

B:BD[22.684832] → [26.55929:56007]

                            && !is_alive(txn, channel, vertex.inode_vertex())

[22.684832]

[22.684909]

                            && !is_alive(txn, channel, vertex.inode_vertex())?

Replacement in libpijul/src/output/output.rs at line 368 [22.671807]

B:BD[22.685037] → [22.685037:685124]

                    dead.insert(id.to_owned(), (inode_, inode_filename(txn, inode_)));

[22.685037]

[22.685124]

                    dead.insert(id.to_owned(), (inode_, inode_filename(txn, inode_)?));

Replacement in libpijul/src/output/output.rs at line 377 [22.671807]
B:BD[22.685337] → [22.685337:685346]
```
    dead
```
[22.685337]
[22.685346]
```
    Ok(dead)
```

Replacement in libpijul/src/output/output.rs at line 380 [22.671807]

B:BD[23.22808] → [23.22808:22872]

fn kill_dead_files<T: MutTxnT, W: WorkingCopy, C: ChangeStore>(

[23.22808]

[22.685451]

fn kill_dead_files<T: TreeMutTxnT, W: WorkingCopy, C: ChangeStore>(

Replacement in libpijul/src/output/output.rs at line 384 [22.671807]
B:BD[22.685544] → [23.22873:22934]
```
) -> Result<(), OutputError<C::Error, T::Error, W::Error>> {
```
[22.685544]
[22.685577]
```
) -> Result<(), OutputError<C::Error, T::TreeError, W::Error>> {
```

Replacement in libpijul/src/output/output.rs at line 387 [22.671807]

B:BD[22.685693] → [23.22935:23031]

∅:D[41.2703] → [22.685885:685946]

∅:D[23.23031] → [22.685885:685946]

B:BD[22.685885] → [22.685885:685946]

        del_tree_with_rev(txn, fileid.as_file_id(), *inode).map_err(PristineOutputError::Txn)?;
        if let Some(vertex) = txn.get_inodes(*inode, None) {

[22.685693]

[41.2704]

        del_tree_with_rev(txn, fileid.as_file_id(), *inode)?;
        if let Some(vertex) = txn.get_inodes(*inode, None)? {

Replacement in libpijul/src/output/output.rs at line 390 [22.671807]

B:BD[41.2768] → [23.23032:23121]

            del_inodes_with_rev(txn, *inode, vertex).map_err(PristineOutputError::Txn)?;

[41.2768]

[22.686069]

            del_inodes_with_rev(txn, *inode, vertex)?;

Insertion in libpijul/src/output/mod.rs at line 46 [22.686190]

[23.24228]

    }
}
impl<C: std::error::Error, T: std::error::Error + 'static> From<TxnErr<T>>
    for PristineOutputError<C, T>
{
    fn from(e: TxnErr<T>) -> Self {
        PristineOutputError::Txn(e.0)
    }
}
impl<C: std::error::Error, T: std::error::Error + 'static, W: std::error::Error> From<TxnErr<T>>
    for OutputError<C, T, W>
{
    fn from(e: TxnErr<T>) -> Self {
        OutputError::Pristine(e.into())

Replacement in libpijul/src/output/mod.rs at line 66 [22.686190]

B:BD[23.24261] → [23.24261:24329]

pub enum FileError<ChangestoreError: std::error::Error + 'static> {

[23.24261]

[23.24329]

pub enum FileError<ChangestoreError: std::error::Error + 'static, T: std::error::Error + 'static> {

Insertion in libpijul/src/output/mod.rs at line 69 [22.686190]
[23.24390]
[23.24390]
```
    #[error(transparent)]
    Txn(T),
```

Replacement in libpijul/src/output/mod.rs at line 75 [22.686190]

B:BD[23.24451] → [23.24451:24529]

impl<C: std::error::Error, T: std::error::Error + 'static> From<FileError<C>>

[23.24451]

[23.24529]

impl<C: std::error::Error, T: std::error::Error + 'static> From<FileError<C, T>>

Replacement in libpijul/src/output/mod.rs at line 78 [22.686190]
B:BD[23.24565] → [23.24565:24604]
```
    fn from(e: FileError<C>) -> Self {
```
[23.24565]
[23.24604]
```
    fn from(e: FileError<C, T>) -> Self {
```
Insertion in libpijul/src/output/mod.rs at line 82 [22.686190]
[23.24760]
[23.24760]
```
            FileError::Txn(t) => PristineOutputError::Txn(t),
```

Insertion in libpijul/src/output/mod.rs at line 87 [22.686190]

[23.24779]

[22.686366]

impl<C: std::error::Error, T: std::error::Error + 'static> From<TxnErr<T>> for FileError<C, T> {
    fn from(e: TxnErr<T>) -> Self {
        FileError::Txn(e.0)
    }
}

Deletion in libpijul/src/output/mod.rs at line 99 [22.686190]
B:BD[22.686494] → [22.686494:686542]
```
    inode: Option<(Inode, Position<ChangeId>)>,
```
Replacement in libpijul/src/output/mod.rs at line 102 [22.686190]
B:BD[22.686566] → [22.686566:686612]
```
fn collect_children<T: TxnT, P: ChangeStore>(
```
[22.686566]
[22.686612]
```
fn collect_children<T: GraphTxnT, P: ChangeStore>(
```
Replacement in libpijul/src/output/mod.rs at line 105 [22.686190]
B:BD[22.686642] → [22.686642:686668]
```
    channel: &Channel<T>,
```
[22.686642]
[22.686668]
```
    channel: &T::Graph,
```
Replacement in libpijul/src/output/mod.rs at line 111 [22.686190]
B:BD[22.686842] → [23.24780:24839]
```
) -> Result<(), PristineOutputError<P::Error, T::Error>> {
```
[22.686842]
[22.686875]
```
) -> Result<(), PristineOutputError<P::Error, T::GraphError>> {
```
Replacement in libpijul/src/output/mod.rs at line 115 [22.686190]
∅:D[26.56049] → [22.686940:686958]
B:BD[22.686940] → [22.686940:686958]
```
        &channel,
```
[26.56049]
[22.686958]
```
        channel,
```

Deletion in libpijul/src/output/mod.rs at line 117 [22.686190]

B:BD[22.686992] → [22.686992:687102]

B:BD[22.687102] → [26.56050:56091]

∅:D[26.56091] → [22.687134:687186]

B:BD[22.687134] → [22.687134:687186]

        EdgeFlags::empty(),
        EdgeFlags::all(),
    ) {
        debug!("inode_pos, e = {:?}", e);
    }
    for e in iter_adjacent(
        txn,
        &channel,
        inode_pos.inode_vertex(),

Replacement in libpijul/src/output/mod.rs at line 119 [22.686190]

B:BD[22.687279] → [22.687279:687287]

B:BD[22.687350] → [22.687350:687411]

B:BD[22.687411] → [26.56092:56162]

    ) {
        // This unwrap is ok since e.dest is in the channel.
        let name_vertex = find_block(txn, &channel, e.dest).unwrap();

[22.687279]

[22.687480]

    )? {
        let e = e?;
        let name_vertex = find_block(txn, channel, e.dest).unwrap();

Replacement in libpijul/src/output/mod.rs at line 124 [22.686190]

B:BD[23.24856] → [23.24856:24999]

            .get_contents(|h| txn.get_external(h), name_vertex, &mut name_buf)
            .map_err(|e| PristineOutputError::Changestore(e))?;

[23.24856]

[22.687603]

            .get_contents(|h| txn.get_external(h).unwrap(), name_vertex, &mut name_buf)
            .map_err(PristineOutputError::Changestore)?;

Deletion in libpijul/src/output/mod.rs at line 140 [22.686190]

B:BD[22.688203] → [26.56163:56333]

∅:D[26.56333] → [22.688301:688346]

B:BD[22.688301] → [22.688301:688346]

        for e in iter_adjacent(
            txn,
            &channel,
            name_vertex,
            EdgeFlags::empty(),
            EdgeFlags::all(),
        ) {
            debug!("e = {:?}", e);
        }

Replacement in libpijul/src/output/mod.rs at line 142 [22.686190]
B:BD[26.56407] → [26.56407:56429]
```
            &channel,
```
[26.56407]
[26.56429]
```
            channel,
```
Replacement in libpijul/src/output/mod.rs at line 146 [22.686190]
B:BD[26.56555] → [26.56555:56565]
```
        )
```
[26.56555]
[26.56565]
```
        )?
```
Replacement in libpijul/src/output/mod.rs at line 149 [22.686190]
B:BD[26.56591] → [26.56591:56609]
```
            child
```
[26.56591]
[26.56609]
```
            child?
```

Replacement in libpijul/src/output/mod.rs at line 151 [22.686190]

B:BD[26.56626] → [26.56626:56665]

            let child = iter_adjacent(

[26.56626]

[26.56665]

            let mut edge = None;
            for e in iter_adjacent(

Replacement in libpijul/src/output/mod.rs at line 154 [22.686190]
∅:D[26.56686] → [22.688419:688445]
B:BD[22.688419] → [22.688419:688445]
```
                &channel,
```
[26.56686]
[22.688445]
```
                channel,
```

Replacement in libpijul/src/output/mod.rs at line 158 [22.686190]

∅:D[26.56721] → [22.688583:688597]

B:BD[22.688583] → [22.688583:688597]

B:BD[22.688597] → [39.4898:4957]

∅:D[39.4957] → [26.56784:56807]

B:BD[22.688617] → [26.56784:56807]

∅:D[26.56807] → [22.688897:688898]

B:BD[22.688897] → [22.688897:688898]

            )
            .find(|e| !e.flag.contains(EdgeFlags::PARENT))
            .unwrap();

[26.56721]

[22.688898]

            )? {
                let e = e?;
                if !e.flag.contains(EdgeFlags::PARENT) {
                    edge = Some(e);
                    break;
                }
            }
            let e = edge.unwrap();

Replacement in libpijul/src/output/mod.rs at line 167 [22.686190]

B:BD[22.688970] → [42.873:962]

            debug_root(txn, channel, child.dest.inode_vertex(), &mut f, false).unwrap();

[22.688970]

[22.689072]

            debug_root(txn, channel, e.dest.inode_vertex(), &mut f, false).unwrap();

Deletion in libpijul/src/output/mod.rs at line 172 [22.686190]

B:BD[22.689154] → [22.689154:689352]

        let child_inode = txn
            .get_revinodes(child.dest, None)
            .map(|inode| (inode, txn.get_inodes(inode, None).unwrap()));
        debug!("child_inode: {:?}", child_inode);

Replacement in libpijul/src/output/mod.rs at line 180 [22.686190]

B:BD[22.689609] → [22.689609:689709]

                inode: child_inode,
                is_zombie: is_zombie(txn, channel, child.dest),

[22.689609]

[22.689709]

                is_zombie: is_zombie(txn, channel, child.dest)?,

Replacement in libpijul/src/output/mod.rs at line 187 [22.686190]

B:BD[22.689756] → [22.689756:689844]

fn is_zombie<T: TxnT>(txn: &T, channel: &Channel<T>, pos: Position<ChangeId>) -> bool {

[22.689756]

[22.689844]

fn is_zombie<T: GraphTxnT>(
    txn: &T,
    channel: &T::Graph,
    pos: Position<ChangeId>,
) -> Result<bool, TxnErr<T::GraphError>> {

Replacement in libpijul/src/output/mod.rs at line 193 [22.686190]

B:BD[22.689916] → [26.56895:56973]

∅:D[26.56973] → [22.689993:690028]

B:BD[22.689993] → [22.689993:690028]

    iter_adjacent(txn, &channel, pos.inode_vertex(), f, f | EdgeFlags::BLOCK)
        .next()
        .is_some()

[22.689916]

[22.690028]

    if let Some(n) =
        iter_adjacent(txn, channel, pos.inode_vertex(), f, f | EdgeFlags::BLOCK)?.next()
    {
        n?;
        Ok(true)
    } else {
        Ok(false)
    }

Insertion in libpijul/src/output/archive.rs at line 86 [22.690044]
[23.25418]
[23.25418]
```
    #[error(transparent)]
    P(P),
```
Replacement in libpijul/src/output/archive.rs at line 97 [22.690044]
B:BD[23.25744] → [23.25744:25791]
```
    File(#[from] crate::output::FileError<P>),
```
[23.25744]
[23.25791]
```
    File(#[from] crate::output::FileError<P, T>),
```

Replacement in libpijul/src/output/archive.rs at line 102 [22.690044]

B:BD[22.692169] → [22.692169:692262]

pub(crate) fn archive<'a, T: TxnT, P: ChangeStore, I: Iterator<Item = &'a str>, A: Archive>(

[22.692169]

[22.692262]

impl<
        P: std::error::Error + 'static,
        T: std::error::Error + 'static,
        A: std::error::Error + 'static,
    > std::convert::From<TxnErr<T>> for ArchiveError<P, T, A>
{
    fn from(e: TxnErr<T>) -> Self {
        ArchiveError::Txn(e.0)
    }
}
pub(crate) fn archive<
    'a,
    T: ChannelTxnT,
    P: ChangeStore,
    I: Iterator<Item = &'a str>,
    A: Archive,
>(

Replacement in libpijul/src/output/archive.rs at line 125 [22.690044]

B:BD[22.692359] → [23.25880:25953]

) -> Result<Vec<Conflict>, ArchiveError<P::Error, T::Error, A::Error>> {

[22.692359]

[22.692403]

) -> Result<Vec<Conflict>, ArchiveError<P::Error, T::GraphError, A::Error>> {

Replacement in libpijul/src/output/archive.rs at line 134 [22.690044]
B:BD[22.692654] → [22.692654:692672]
```
        &channel,
```
[22.692654]
[22.692672]
```
        &channel.graph,
```

Replacement in libpijul/src/output/archive.rs at line 175 [22.690044]

B:BD[22.694102] → [22.694102:694350]

                if let Some((inode, _)) = output_item.inode {
                    if !done_inodes.insert(inode) {
                        debug!("inode already visited: {:?} {:?}", a, inode);
                        continue;
                    }

[22.694102]

[22.694350]

                if !done_inodes.insert(output_item.pos) {
                    debug!("inode already visited: {:?} {:?}", a, output_item.pos);
                    continue;

Replacement in libpijul/src/output/archive.rs at line 195 [22.690044]
B:BD[22.695038] → [22.695038:695072]
```
                        &channel,
```
[22.695038]
[22.695072]
```
                        &channel.graph,
```
Replacement in libpijul/src/output/archive.rs at line 201 [22.690044]
B:BD[22.695278] → [22.695278:695301]
```
                    )?
```
[22.695278]
[22.695301]
```
                    )?;
```

Replacement in libpijul/src/output/archive.rs at line 203 [22.690044]

B:BD[22.695326] → [22.695326:695414]

                    let mut l = crate::alive::retrieve(txn, &channel, output_item.pos);

[22.695326]

[22.695414]

                    let mut l = crate::alive::retrieve(txn, &channel.graph, output_item.pos)?;

Replacement in libpijul/src/missing_context.rs at line 13 [22.696460]
B:BD[23.26180] → [23.26180:26211]
```
    Block(#[from] BlockError),
```
[23.26180]
[23.26211]
```
    Block(#[from] BlockError<TxnError>),
```

Replacement in libpijul/src/missing_context.rs at line 15 [22.696460]

B:BD[23.26237] → [23.26237:26283]

    Inconsistent(#[from] InconsistentChange),

[23.26237]

[23.26283]

    Inconsistent(#[from] InconsistentChange<TxnError>),
}
impl<T: std::error::Error + 'static> std::convert::From<TxnErr<T>> for MissingError<T> {
    fn from(e: TxnErr<T>) -> Self {
        MissingError::Txn(e.0)
    }

Replacement in libpijul/src/missing_context.rs at line 25 [22.696460]
B:BD[22.696724] → [22.696724:696763]
```
    pub(crate) fn load_graph<T: TxnT>(
```
[22.696724]
[22.696763]
```
    pub(crate) fn load_graph<T: GraphTxnT>(
```
Replacement in libpijul/src/missing_context.rs at line 28 [22.696460]
B:BD[22.696799] → [22.696799:696829]
```
        channel: &Channel<T>,
```
[22.696799]
[22.696829]
```
        channel: &T::Graph,
```

Replacement in libpijul/src/missing_context.rs at line 30 [22.696460]

B:BD[22.696868] → [23.26286:26379]

    ) -> Result<Option<&(Graph, HashMap<Vertex<ChangeId>, VertexId>)>, InconsistentChange> {

[22.696868]

[22.696955]

    ) -> Result<
        Option<&(Graph, HashMap<Vertex<ChangeId>, VertexId>)>,
        InconsistentChange<T::GraphError>,
    > {

Replacement in libpijul/src/missing_context.rs at line 39 [22.696460]

B:BD[22.697186] → [22.697186:697262]

                        change: if let Some(i) = txn.get_internal(change) {

[22.697186]

[22.697262]

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

Replacement in libpijul/src/missing_context.rs at line 42 [22.696460]

B:BD[22.697325] → [23.26380:26443]

                            return Err(InconsistentChange {});

[22.697325]

[22.697406]

                            return Err(InconsistentChange::UndeclaredDep);

Replacement in libpijul/src/missing_context.rs at line 46 [22.696460]

B:BD[22.697496] → [22.697496:697575]

                    let mut graph = crate::alive::retrieve(txn, channel, pos);

[22.697496]

[22.697575]

                    let mut graph = crate::alive::retrieve(txn, channel, pos)?;

Replacement in libpijul/src/missing_context.rs at line 63 [22.696460]
B:BD[22.698054] → [22.698054:698070]
```
    T: MutTxnT,
```
[22.698054]
[22.698070]
```
    T: GraphMutTxnT,
```
Replacement in libpijul/src/missing_context.rs at line 67 [22.696460]
B:BD[22.698140] → [22.698140:698170]
```
    channel: &mut Channel<T>,
```
[22.698140]
[22.698170]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/missing_context.rs at line 73 [22.696460]
B:BD[22.698287] → [23.26446:26488]
```
) -> Result<(), MissingError<T::Error>> {
```
[22.698264]
[22.698320]
```
) -> Result<(), MissingError<T::GraphError>> {
```

Replacement in libpijul/src/missing_context.rs at line 90 [22.696460]

B:BD[22.698941] → [21.9620:9719]

        repair_regular_up(txn, channel, &alive, d, EdgeFlags::PSEUDO).map_err(MissingError::Txn)?;

[22.698941]

[22.699912]

        repair_regular_up(txn, channel, &alive, d, EdgeFlags::PSEUDO)?;

Replacement in libpijul/src/missing_context.rs at line 95 [22.696460]
B:BD[22.699976] → [21.9720:9754]
```
fn repair_regular_up<T: MutTxnT>(
```
[22.699976]
[22.700008]
```
fn repair_regular_up<T: GraphMutTxnT>(
```
Replacement in libpijul/src/missing_context.rs at line 97 [22.696460]
B:BD[22.700025] → [22.700025:700055]
```
    channel: &mut Channel<T>,
```
[22.700025]
[21.9755]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/missing_context.rs at line 101 [22.696460]
B:BD[21.9840] → [21.9840:9868]
```
) -> Result<(), T::Error> {
```
[21.9840]
[21.9868]
```
) -> Result<(), TxnErr<T::GraphError>> {
```
Replacement in libpijul/src/missing_context.rs at line 119 [22.696460]
B:BD[22.700694] → [22.700694:700710]
```
    T: MutTxnT,
```
[22.700694]
[22.700710]
```
    T: GraphMutTxnT,
```
Replacement in libpijul/src/missing_context.rs at line 123 [22.696460]
B:BD[22.700780] → [22.700780:700810]
```
    channel: &mut Channel<T>,
```
[22.700780]
[22.700810]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/missing_context.rs at line 128 [22.696460]
B:BD[22.700904] → [23.26697:26739]
```
) -> Result<(), MissingError<T::Error>> {
```
[22.700904]
[22.700937]
```
) -> Result<(), MissingError<T::GraphError>> {
```

Replacement in libpijul/src/missing_context.rs at line 148 [22.696460]

B:BD[21.10564] → [21.10564:10699]

            put_graph_with_rev(txn, channel, EdgeFlags::PSEUDO, d, desc, ChangeId::ROOT)
                .map_err(MissingError::Txn)?;

[21.10564]

[22.701825]

            put_graph_with_rev(txn, channel, EdgeFlags::PSEUDO, d, desc, ChangeId::ROOT)?;

Replacement in libpijul/src/missing_context.rs at line 154 [22.696460]
∅:D[23.26798] → [22.701909:701965]
B:BD[22.701909] → [22.701909:701965]
```
pub(crate) fn repair_context_nondeleted<T: MutTxnT, K>(
```
[23.26798]
[22.701965]
```
pub(crate) fn repair_context_nondeleted<T: GraphMutTxnT, K>(
```
Replacement in libpijul/src/missing_context.rs at line 156 [22.696460]
B:BD[22.701982] → [22.701982:702012]
```
    channel: &mut Channel<T>,
```
[22.701982]
[22.702012]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/missing_context.rs at line 162 [22.696460]
B:BD[22.702145] → [23.26799:26839]
```
) -> Result<(), MissingError<T::Error>>
```
[22.702145]
[22.702176]
```
) -> Result<(), MissingError<T::GraphError>>
```

Replacement in libpijul/src/missing_context.rs at line 175 [22.696460]

B:BD[21.10983] → [21.10983:11056]

    if deleted_by_unknown(txn, channel, source, change_id, &mut known) {

[21.10983]

[21.11056]

    if deleted_by_unknown(txn, channel, source, change_id, &mut known)? {

Replacement in libpijul/src/missing_context.rs at line 183 [22.696460]
B:BD[22.704009] → [21.11304:11340]
```
fn reconnect_target_up<T: MutTxnT>(
```
[22.704009]
[21.11340]
```
fn reconnect_target_up<T: GraphMutTxnT>(
```
Replacement in libpijul/src/missing_context.rs at line 185 [22.696460]
B:BD[21.11357] → [21.11357:11387]
```
    channel: &mut Channel<T>,
```
[21.11357]
[21.11387]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/missing_context.rs at line 190 [22.696460]
B:BD[21.11501] → [21.11501:11543]
```
) -> Result<(), MissingError<T::Error>> {
```
[21.11501]
[22.704175]
```
) -> Result<(), MissingError<T::GraphError>> {
```

Replacement in libpijul/src/missing_context.rs at line 192 [22.696460]

B:BD[22.704213] → [21.11544:11602]

    for v in iter_deleted_parents(txn, channel, target) {

[22.704213]

[21.11602]

    for v in iter_deleted_parents(txn, channel, target)? {
        let v = v?;

Replacement in libpijul/src/missing_context.rs at line 211 [22.696460]
B:BD[22.704871] → [21.11925:11966]
```
fn reconnect_target_down<T: MutTxnT, K>(
```
[22.704871]
[21.11966]
```
fn reconnect_target_down<T: GraphMutTxnT, K>(
```
Replacement in libpijul/src/missing_context.rs at line 213 [22.696460]
B:BD[21.11983] → [21.11983:12013]
```
    channel: &mut Channel<T>,
```
[21.11983]
[21.12013]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/missing_context.rs at line 219 [22.696460]
B:BD[21.12146] → [21.12146:12186]
```
) -> Result<(), MissingError<T::Error>>
```
[21.12146]
[21.12186]
```
) -> Result<(), MissingError<T::GraphError>>
```

Replacement in libpijul/src/missing_context.rs at line 225 [22.696460]

B:BD[22.705017] → [21.12223:12273]

    for v in iter_adj_all(txn, channel, target) {

[22.705017]

[22.705105]

    for v in iter_adj_all(txn, channel, target)? {
        let v = v?;

Replacement in libpijul/src/missing_context.rs at line 237 [22.696460]

B:BD[22.705429] → [22.705429:705493]

        let intro = txn.get_external(v.introduced_by).unwrap();

[22.705429]

[22.705493]

        let intro = txn.get_external(v.introduced_by)?.unwrap();

Replacement in libpijul/src/missing_context.rs at line 249 [22.696460]
B:BD[21.12277] → [21.12277:12312]
```
fn deleted_by_unknown<T: TxnT, K>(
```
[21.12277]
[21.12312]
```
fn deleted_by_unknown<T: GraphTxnT, K>(
```
Replacement in libpijul/src/missing_context.rs at line 251 [22.696460]
B:BD[21.12325] → [21.12325:12351]
```
    channel: &Channel<T>,
```
[21.12325]
[21.12351]
```
    channel: &T::Graph,
```
Replacement in libpijul/src/missing_context.rs at line 255 [22.696460]
B:BD[21.12425] → [21.12425:12435]
```
) -> bool
```
[21.12425]
[21.12435]
```
) -> Result<bool, TxnErr<T::GraphError>>
```

Replacement in libpijul/src/missing_context.rs at line 260 [22.696460]

B:BD[21.12511] → [21.12511:12569]

    for v in iter_deleted_parents(txn, channel, source) {

[21.12511]

[21.12569]

    for v in iter_deleted_parents(txn, channel, source)? {
        let v = v?;

Replacement in libpijul/src/missing_context.rs at line 265 [22.696460]

B:BD[21.12667] → [21.12667:12762]

        if v.introduced_by == change_id || known(txn.get_external(v.introduced_by).unwrap()) {

[21.12667]

[21.12762]

        if v.introduced_by == change_id || known(txn.get_external(v.introduced_by)?.unwrap()) {

Replacement in libpijul/src/missing_context.rs at line 267 [22.696460]
B:BD[21.12832] → [21.12832:12858]
```
            return false;
```
[21.12832]
[21.12858]
```
            return Ok(false);
```
Replacement in libpijul/src/missing_context.rs at line 274 [22.696460]
B:BD[21.13049] → [21.13049:13072]
```
    deleted_by_unknown
```
[21.13049]
[22.705747]
```
    Ok(deleted_by_unknown)
```
Replacement in libpijul/src/missing_context.rs at line 277 [22.696460]
B:BD[22.705805] → [22.705805:705858]
```
pub(crate) fn repair_context_deleted<T: MutTxnT, K>(
```
[22.705750]
[22.705858]
```
pub(crate) fn repair_context_deleted<T: GraphMutTxnT, K>(
```
Replacement in libpijul/src/missing_context.rs at line 279 [22.696460]
B:BD[22.705875] → [22.705875:705905]
```
    channel: &mut Channel<T>,
```
[22.705875]
[22.705905]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/missing_context.rs at line 285 [22.696460]
B:BD[22.706038] → [23.26840:26880]
```
) -> Result<(), MissingError<T::Error>>
```
[22.706038]
[22.706069]
```
) -> Result<(), MissingError<T::GraphError>>
```

Replacement in libpijul/src/missing_context.rs at line 332 [22.696460]

B:BD[21.13518] → [21.13518:13733]

    ) -> Result<&(Graph, HashMap<Vertex<ChangeId>, VertexId>), InconsistentChange> {
        if let Some(n) = self.0.get(&inode) {
            Ok(n)
        } else {
            Err(InconsistentChange {})
        }

[21.13518]

[21.13733]

    ) -> Option<&(Graph, HashMap<Vertex<ChangeId>, VertexId>)> {
        self.0.get(&inode)

Replacement in libpijul/src/missing_context.rs at line 378 [22.696460]
B:BD[22.708025] → [22.708025:708066]
```
fn collect_unknown_children<T: TxnT, K>(
```
[22.708025]
[22.708066]
```
fn collect_unknown_children<T: GraphTxnT, K>(
```
Replacement in libpijul/src/missing_context.rs at line 380 [22.696460]
B:BD[22.708079] → [22.708079:708105]
```
    channel: &Channel<T>,
```
[22.708079]
[22.708105]
```
    channel: &T::Graph,
```
Replacement in libpijul/src/missing_context.rs at line 385 [22.696460]
B:BD[22.708208] → [22.708208:708216]
```
) where
```
[22.708208]
[22.708216]
```
) -> Result<(), TxnErr<T::GraphError>>
where
```

Replacement in libpijul/src/missing_context.rs at line 389 [22.696460]

B:BD[22.708246] → [21.14368:14430]

    for v in iter_alive_children(txn, channel, dest_vertex) {

[22.708246]

[26.58199]

    for v in iter_alive_children(txn, channel, dest_vertex)? {
        let v = v?;

Replacement in libpijul/src/missing_context.rs at line 402 [22.696460]
B:BD[22.708829] → [26.58323:58350]
```
        if !iter_adjacent(
```
[22.708668]
[26.58350]
```
        let mut not_del_by_change = true;
        for e in iter_adjacent(
```

Replacement in libpijul/src/missing_context.rs at line 409 [22.696460]

B:BD[26.58495] → [26.58495:58558]

∅:D[26.58558] → [22.709088:709098]

B:BD[22.709088] → [22.709088:709098]

B:BD[22.709161] → [22.709161:709229]

        )
        .any(|e| e.introduced_by == v.introduced_by)
        {
            let intro = txn.get_external(v.introduced_by).unwrap();

[26.58495]

[22.709229]

        )? {
            let e = e?;
            if e.introduced_by == v.introduced_by {
                not_del_by_change = false;
                break;
            }
        }
        if not_del_by_change {
            let intro = txn.get_external(v.introduced_by)?.unwrap();

Insertion in libpijul/src/missing_context.rs at line 423 [22.696460]
[22.709326]
[22.709326]
```
    Ok(())
```
Replacement in libpijul/src/missing_context.rs at line 426 [22.696460]
B:BD[22.709329] → [22.709329:709375]
```
fn repair_children_of_deleted<T: MutTxnT, K>(
```
[22.709329]
[22.709375]
```
fn repair_children_of_deleted<T: GraphMutTxnT, K>(
```
Replacement in libpijul/src/missing_context.rs at line 428 [22.696460]
B:BD[22.709392] → [22.709392:709422]
```
    channel: &mut Channel<T>,
```
[22.709392]
[22.709422]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/missing_context.rs at line 434 [22.696460]
B:BD[22.709559] → [23.26883:26923]
```
) -> Result<(), MissingError<T::Error>>
```
[22.709559]
[22.709590]
```
) -> Result<(), MissingError<T::GraphError>>
```

Replacement in libpijul/src/missing_context.rs at line 439 [22.696460]

B:BD[22.709745] → [22.709745:709829]

    collect_unknown_children(txn, channel, ws, dest_vertex, change_id, &mut known);

[22.709745]

[22.709829]

    collect_unknown_children(txn, channel, ws, dest_vertex, change_id, &mut known)?;

Replacement in libpijul/src/missing_context.rs at line 446 [22.696460]

B:BD[21.14621] → [21.14621:14706]

∅:D[21.14706] → [23.26938:26980]

B:BD[23.26938] → [23.26938:26980]

        put_graph_with_rev(txn, channel, EdgeFlags::db(), dest_vertex, p, change_id)
            .map_err(MissingError::Txn)?;

[21.14621]

[21.14707]

        put_graph_with_rev(txn, channel, EdgeFlags::db(), dest_vertex, p, change_id)?;

Replacement in libpijul/src/missing_context.rs at line 451 [22.696460]

B:BD[21.14894] → [21.14894:14977]

∅:D[21.14977] → [23.27003:27053]

B:BD[23.27003] → [23.27003:27053]

                put_graph_with_rev(txn, channel, EdgeFlags::db(), u, v, change_id)
                    .map_err(MissingError::Txn)?;

[21.14894]

[21.14978]

                put_graph_with_rev(txn, channel, EdgeFlags::db(), u, v, change_id)?;

Replacement in libpijul/src/missing_context.rs at line 457 [22.696460]
B:BD[22.711106] → [21.15045:15084]
```
        if is_alive(txn, channel, p) {
```
[22.711106]
[21.15084]
```
        if is_alive(txn, channel, p)? {
```
Replacement in libpijul/src/missing_context.rs at line 468 [22.696460]
∅:D[26.58891] → [22.711693:711740]
B:BD[22.711693] → [22.711693:711740]
```
pub(crate) fn delete_pseudo_edges<T: MutTxnT>(
```
[26.58891]
[22.711740]
```
pub(crate) fn delete_pseudo_edges<T: GraphMutTxnT>(
```
Replacement in libpijul/src/missing_context.rs at line 470 [22.696460]
B:BD[22.711757] → [22.711757:711787]
```
    channel: &mut Channel<T>,
```
[22.711757]
[22.711787]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/missing_context.rs at line 472 [22.696460]
B:BD[22.711811] → [23.27054:27096]
```
) -> Result<(), MissingError<T::Error>> {
```
[22.711811]
[22.711844]
```
) -> Result<(), MissingError<T::GraphError>> {
```

Replacement in libpijul/src/missing_context.rs at line 478 [22.696460]

B:BD[22.712042] → [59.252:341]

        if !is_alive(txn, channel, dest_vertex) && !ws.repaired.contains(&dest_vertex) {

[22.712042]

[22.712091]

        if !is_alive(txn, channel, dest_vertex)? && !ws.repaired.contains(&dest_vertex) {

Replacement in libpijul/src/missing_context.rs at line 481 [22.696460]

B:BD[26.59006] → [26.59006:59054]

                if !is_alive(txn, channel, p) {

[26.59006]

[26.59054]

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

Replacement in libpijul/src/missing_context.rs at line 484 [22.696460]

B:BD[21.15382] → [21.15382:15530]

                    del_graph_with_rev(txn, channel, e.flag, p, dest_vertex, e.introduced_by)
                        .map_err(MissingError::Txn)?;

[21.15382]

[22.712510]

                    del_graph_with_rev(txn, channel, e.flag, p, dest_vertex, e.introduced_by)?;

Replacement in libpijul/src/missing_context.rs at line 488 [22.696460]

B:BD[26.59247] → [26.59247:59295]

                if !is_alive(txn, channel, p) {

[26.59247]

[26.59295]

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

Replacement in libpijul/src/missing_context.rs at line 490 [22.696460]

B:BD[26.59363] → [23.27170:27318]

                    del_graph_with_rev(txn, channel, e.flag, dest_vertex, p, e.introduced_by)
                        .map_err(MissingError::Txn)?;

[26.59363]

[22.712749]

                    del_graph_with_rev(txn, channel, e.flag, dest_vertex, p, e.introduced_by)?;

Replacement in libpijul/src/missing_context.rs at line 498 [22.696460]
B:BD[22.712811] → [22.712811:712864]
```
pub(crate) fn collect_zombie_context<T: MutTxnT, K>(
```
[22.712811]
[22.712864]
```
pub(crate) fn collect_zombie_context<T: GraphMutTxnT, K>(
```
Replacement in libpijul/src/missing_context.rs at line 500 [22.696460]
B:BD[22.712881] → [22.712881:712911]
```
    channel: &mut Channel<T>,
```
[22.712881]
[22.712911]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/missing_context.rs at line 506 [22.696460]
B:BD[22.713044] → [23.27319:27359]
```
) -> Result<(), MissingError<T::Error>>
```
[22.713044]
[22.713075]
```
) -> Result<(), MissingError<T::GraphError>>
```
Replacement in libpijul/src/missing_context.rs at line 524 [22.696460]
B:BD[22.713587] → [22.713587:713599]
```
        ) {
```
[22.713587]
[22.713599]
```
        )? {
            let v = v?;
```

Replacement in libpijul/src/missing_context.rs at line 535 [22.696460]

B:BD[22.713956] → [22.713956:714028]

                let intro = txn.get_external(v.introduced_by).unwrap();

[22.713956]

[22.714028]

                let intro = txn.get_external(v.introduced_by)?.unwrap();

Replacement in libpijul/src/missing_context.rs at line 552 [22.696460]
B:BD[22.714391] → [22.714391:714415]
```
fn zombify<T: MutTxnT>(
```
[22.714391]
[22.714415]
```
fn zombify<T: GraphMutTxnT>(
```
Replacement in libpijul/src/missing_context.rs at line 554 [22.696460]
B:BD[22.714432] → [22.714432:714462]
```
    channel: &mut Channel<T>,
```
[22.714432]
[22.714462]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/missing_context.rs at line 560 [22.696460]
B:BD[22.714609] → [23.27360:27402]
```
) -> Result<(), MissingError<T::Error>> {
```
[22.714609]
[22.714642]
```
) -> Result<(), MissingError<T::GraphError>> {
```

Replacement in libpijul/src/missing_context.rs at line 577 [22.696460]

B:BD[22.715820] → [23.27403:27467]

                )
                .map_err(MissingError::Txn)?;

[22.715820]

[22.715840]

)?;

Replacement in libpijul/src/missing_context.rs at line 590 [22.696460]
B:BD[22.716138] → [22.716138:716150]
```
        ) {
```
[22.716138]
[22.716150]
```
        )? {
            let parent = parent?;
```

Replacement in libpijul/src/missing_context.rs at line 603 [22.696460]

B:BD[22.716619] → [23.27468:27592]

            put_graph_with_rev(txn, channel, flag, parent_dest, v, change_id)
                .map_err(MissingError::Txn)?;

[22.716619]

[22.716698]

            put_graph_with_rev(txn, channel, flag, parent_dest, v, change_id)?;

Replacement in libpijul/src/missing_context.rs at line 609 [22.696460]
B:BD[22.716728] → [22.716728:716781]
```
pub(crate) fn repair_parents_of_deleted<T: MutTxnT>(
```
[22.716728]
[22.716781]
```
pub(crate) fn repair_parents_of_deleted<T: GraphMutTxnT>(
```
Replacement in libpijul/src/missing_context.rs at line 611 [22.696460]
B:BD[22.716798] → [22.716798:716828]
```
    channel: &mut Channel<T>,
```
[22.716798]
[22.716828]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/missing_context.rs at line 613 [22.696460]
B:BD[22.716852] → [23.27593:27635]
```
) -> Result<(), MissingError<T::Error>> {
```
[22.716852]
[22.716885]
```
) -> Result<(), MissingError<T::GraphError>> {
```

Replacement in libpijul/src/lib.rs at line 98 [22.717381]

B:BD[26.60252] → [57.3293:3419]

    Base32, ChangeId, Channel, ChannelRef, EdgeFlags, Hash, Inode, Merkle, MutTxnT, OwnedPathId,
    RemoteRef, TxnT, Vertex,

[26.60252]

[26.60358]

    Base32, ChangeId, Channel, ChannelRef, ChannelTxnT, DepsTxnT, EdgeFlags, GraphTxnT, Hash,
    Inode, Merkle, MutTxnT, OwnedPathId, RemoteRef, TreeTxnT, TxnT, Vertex,

Replacement in libpijul/src/lib.rs at line 116 [22.717381]

B:BD[22.720799] → [23.27741:27833]

    ) -> Result<(u64, pristine::Merkle), crate::apply::ApplyError<C::Error, Self::Error>> {

[22.720799]

[22.720857]

    ) -> Result<(u64, pristine::Merkle), crate::apply::ApplyError<C::Error, Self::GraphError>> {

Replacement in libpijul/src/lib.rs at line 126 [22.717381]

B:BD[22.721167] → [23.27834:27905]

    ) -> Result<(), crate::apply::ApplyError<C::Error, Self::Error>> {

[22.721167]

[22.721204]

    ) -> Result<(), crate::apply::ApplyError<C::Error, Self::GraphError>> {

Replacement in libpijul/src/lib.rs at line 135 [22.717381]

B:BD[22.721471] → [23.27906:27998]

    ) -> Result<(u64, pristine::Merkle), crate::apply::ApplyError<C::Error, Self::Error>> {

[22.721471]

[22.721529]

    ) -> Result<(u64, pristine::Merkle), crate::apply::ApplyError<C::Error, Self::GraphError>> {

Replacement in libpijul/src/lib.rs at line 144 [22.717381]

B:BD[22.721775] → [23.27999:28070]

    ) -> Result<(), crate::apply::ApplyError<C::Error, Self::Error>> {

[22.721775]

[22.721812]

    ) -> Result<(), crate::apply::ApplyError<C::Error, Self::GraphError>> {

Replacement in libpijul/src/lib.rs at line 153 [22.717381]

B:BD[22.722067] → [23.28071:28142]

    ) -> Result<(), crate::apply::ApplyError<C::Error, Self::Error>> {

[22.722067]

[22.722104]

    ) -> Result<(), crate::apply::ApplyError<C::Error, Self::GraphError>> {

Replacement in libpijul/src/lib.rs at line 164 [22.717381]

B:BD[22.722441] → [23.28143:28230]

    ) -> Result<(u64, pristine::Merkle), crate::apply::LocalApplyError<Self::Error>> {

[22.722441]

[22.722499]

    ) -> Result<(u64, pristine::Merkle), crate::apply::LocalApplyError<Self::GraphError>> {

Replacement in libpijul/src/lib.rs at line 174 [22.717381]

B:BD[22.722831] → [23.28231:28318]

    ) -> Result<(u64, pristine::Merkle), crate::apply::LocalApplyError<Self::Error>> {

[22.722831]

[22.722889]

    ) -> Result<(u64, pristine::Merkle), crate::apply::LocalApplyError<Self::GraphError>> {

Replacement in libpijul/src/lib.rs at line 186 [22.717381]

B:BD[22.723283] → [23.28319:28402]

∅:D[23.28402] → [22.723320:723405]

B:BD[22.723320] → [22.723320:723405]

    ) -> Result<(), crate::record::RecordError<C::Error, W::Error, Self::Error>> {
        builder.record(self, diff_algorithm, channel, working_copy, changes, prefix)

[22.723283]

[22.723405]

    ) -> Result<(), crate::record::RecordError<C::Error, W::Error, Self::GraphError>>
    where
        <W as crate::working_copy::WorkingCopy>::Error: 'static,
    {
        builder.record(
            self,
            diff_algorithm,
            &mut channel.borrow_mut(),
            working_copy,
            changes,
            prefix,
        )

Replacement in libpijul/src/lib.rs at line 207 [22.717381]

B:BD[22.723681] → [23.28403:28500]

    ) -> Result<record::Recorded, crate::record::RecordError<C::Error, W::Error, Self::Error>> {

[22.723681]

[22.723732]

    ) -> Result<record::Recorded, crate::record::RecordError<C::Error, W::Error, Self::GraphError>>
    where
        <W as crate::working_copy::WorkingCopy>::Error: 'static,
    {

Replacement in libpijul/src/lib.rs at line 212 [22.717381]

B:BD[22.723789] → [22.723789:723876]

        builder.record(self, diff_algorithm, channel, working_copy, changes, prefix)?;

[22.723789]

[22.723876]

        builder.record(
            self,
            diff_algorithm,
            &mut channel.borrow_mut(),
            working_copy,
            changes,
            prefix,
        )?;

Replacement in libpijul/src/lib.rs at line 228 [22.717381]

B:BD[22.724094] → [23.28501:28584]

    ) -> Result<pristine::Hash, crate::apply::ApplyError<C::Error, Self::Error>> {

[22.724094]

[22.724183]

    ) -> Result<pristine::Hash, crate::apply::ApplyError<C::Error, Self::GraphError>> {

Replacement in libpijul/src/lib.rs at line 242 [22.717381]

B:BD[22.724655] → [22.724655:724707]

                    .map(|rec| rec.globalize(self))

[22.724655]

[22.724707]

                    .map(|rec| rec.globalize(self).unwrap())

Replacement in libpijul/src/lib.rs at line 264 [22.717381]

B:BD[22.725363] → [23.28706:28778]

    ) -> Result<bool, unrecord::UnrecordError<C::Error, Self::Error>> {

[22.725363]

[22.725402]

    ) -> Result<bool, unrecord::UnrecordError<C::Error, Self::GraphError>> {

Replacement in libpijul/src/lib.rs at line 275 [22.717381]

B:BD[22.725733] → [23.28779:28874]

    ) -> Result<Vec<output::Conflict>, output::OutputError<C::Error, Self::Error, R::Error>> {

[22.725733]

[22.725789]

    ) -> Result<Vec<output::Conflict>, output::OutputError<C::Error, Self::GraphError, R::Error>>
    {

Replacement in libpijul/src/lib.rs at line 290 [22.717381]

B:BD[22.726194] → [23.28875:28956]

    fn add_file(&mut self, path: &str) -> Result<(), fs::FsError<Self::Error>> {

[22.726194]

[22.726264]

    fn add_file(&mut self, path: &str) -> Result<(), fs::FsError<Self::GraphError>> {

Replacement in libpijul/src/lib.rs at line 298 [22.717381]

B:BD[22.726545] → [23.28957:29037]

    fn add_dir(&mut self, path: &str) -> Result<(), fs::FsError<Self::Error>> {

[22.726545]

[22.726614]

    fn add_dir(&mut self, path: &str) -> Result<(), fs::FsError<Self::GraphError>> {

Replacement in libpijul/src/lib.rs at line 305 [22.717381]

B:BD[22.726871] → [23.29038:29128]

    fn add(&mut self, path: &str, is_dir: bool) -> Result<(), fs::FsError<Self::Error>> {

[22.726871]

[22.726950]

    fn add(&mut self, path: &str, is_dir: bool) -> Result<(), fs::FsError<Self::GraphError>> {

Replacement in libpijul/src/lib.rs at line 309 [22.717381]

B:BD[22.727005] → [23.29129:29217]

    fn move_file(&mut self, a: &str, b: &str) -> Result<(), fs::FsError<Self::Error>> {

[22.727005]

[22.727082]

    fn move_file(&mut self, a: &str, b: &str) -> Result<(), fs::FsError<Self::GraphError>> {

Replacement in libpijul/src/lib.rs at line 313 [22.717381]

B:BD[22.727123] → [23.29218:29299]

    fn remove_file(&mut self, a: &str) -> Result<(), fs::FsError<Self::Error>> {

[22.727123]

[22.727193]

    fn remove_file(&mut self, a: &str) -> Result<(), fs::FsError<Self::GraphError>> {

Replacement in libpijul/src/lib.rs at line 323 [22.717381]

B:BD[23.29376] → [23.29376:29439]

        pristine::channel_dump::ChannelDumpError<Self::Error>,

[23.29376]

[23.29439]

        pristine::channel_dump::ChannelDumpError<Self::GraphError>,

Replacement in libpijul/src/lib.rs at line 326 [22.717381]
∅:D[23.29486] → [22.727418:727465]
B:BD[22.727418] → [22.727418:727465]
```
        if self.load_channel(name).is_none() {
```
[23.29486]
[23.29487]
```
        if self.load_channel(name)?.is_none() {
```

Replacement in libpijul/src/lib.rs at line 342 [22.717381]

B:BD[22.728008] → [23.29742:29838]

    ) -> Result<Vec<output::Conflict>, output::ArchiveError<P::Error, Self::Error, A::Error>> {

[22.728008]

[22.728064]

    ) -> Result<Vec<output::Conflict>, output::ArchiveError<P::Error, Self::GraphError, A::Error>>
    {

Replacement in libpijul/src/lib.rs at line 370 [22.717381]

B:BD[22.728757] → [23.29839:29935]

    ) -> Result<Vec<output::Conflict>, output::ArchiveError<P::Error, Self::Error, A::Error>> {

[22.728757]

[22.728813]

    ) -> Result<Vec<output::Conflict>, output::ArchiveError<P::Error, Self::GraphError, A::Error>>
    {

Replacement in libpijul/src/lib.rs at line 374 [22.717381]

B:BD[22.728883] → [26.60445:60532]

        for (_, (h, m)) in pristine::changeid_rev_log(self, &channel.borrow(), None) {

[22.728883]

[22.728959]

        for x in pristine::changeid_rev_log(self, &channel.borrow(), None)? {
            let (_, (h, m)) = x?;

Replacement in libpijul/src/lib.rs at line 386 [22.717381]

B:BD[22.729224] → [22.729224:729279]

                let h = self.get_external(h).unwrap();

[22.729224]

[22.729279]

                let h = self.get_external(h)?.unwrap();

Replacement in libpijul/src/lib.rs at line 400 [22.717381]

B:BD[22.729657] → [22.729657:729756]

    fn is_directory(&self, inode: pristine::Inode) -> bool {
        fs::is_directory(self, inode)

[22.729657]

[22.729756]

    fn is_directory(&self, inode: pristine::Inode) -> Result<bool, Self::TreeError> {
        fs::is_directory(self, inode).map_err(|e| e.0)

Replacement in libpijul/src/lib.rs at line 404 [22.717381]

B:BD[22.729763] → [22.729763:729845]

    fn is_tracked(&self, path: &str) -> bool {
        fs::is_tracked(self, path)

[22.729763]

[22.729845]

    fn is_tracked(&self, path: &str) -> Result<bool, Self::TreeError> {
        fs::is_tracked(self, path).map_err(|e| e.0)

Replacement in libpijul/src/lib.rs at line 416 [22.717381]

B:BD[22.730108] → [22.730108:730131]

B:BD[22.730131] → [39.5019:5080]

∅:D[39.5080] → [22.730259:730324]

B:BD[22.730259] → [22.730259:730324]

    ) -> Option<u64> {
        let cid = pristine::TxnT::get_internal(self, hash)?;
        self.get_changeset(&channel.borrow().changes, cid, None)

[22.730108]

[26.60612]

    ) -> Result<Option<u64>, Self::GraphError> {
        if let Some(cid) = pristine::GraphTxnT::get_internal(self, hash).map_err(|e| e.0)? {
            self.get_changeset(&channel.borrow().changes, cid, None)
                .map_err(|e| e.0)
        } else {
            Ok(None)
        }

Replacement in libpijul/src/lib.rs at line 429 [22.717381]

B:BD[26.60743] → [26.60743:60804]

    ) -> bool {
        pristine::is_alive(self, channel, a)

[26.60743]

[22.730324]

    ) -> Result<bool, Self::GraphError> {
        pristine::is_alive(self, &channel.graph, a).map_err(|e| e.0)

Replacement in libpijul/src/lib.rs at line 433 [22.717381]

B:BD[22.730331] → [16.248:333]

∅:D[16.333] → [26.60898:60945]

B:BD[26.60898] → [26.60898:60945]

    fn current_state(&self, channel: &pristine::Channel<Self>) -> pristine::Merkle {
        pristine::current_state(self, channel)

[22.730331]

[26.60945]

    fn current_state(
        &self,
        channel: &pristine::Channel<Self>,
    ) -> Result<pristine::Merkle, Self::GraphError> {
        pristine::current_state(self, channel).map_err(|e| e.0)

Replacement in libpijul/src/lib.rs at line 444 [22.717381]

B:BD[22.730450] → [22.730450:730491]

    ) -> Log<'txn, Self> {
        Log {

[22.730450]

[22.730491]

    ) -> Result<Log<'txn, Self>, Self::GraphError> {
        Ok(Log {

Replacement in libpijul/src/lib.rs at line 447 [22.717381]

B:BD[22.730514] → [26.60953:61016]

∅:D[26.61016] → [22.730566:730576]

B:BD[22.730566] → [22.730566:730576]

            iter: pristine::changeid_log(self, channel, from),
        }

[22.730514]

[26.61017]

            iter: pristine::changeid_log(self, channel, from).map_err(|e| e.0)?,
        })

Replacement in libpijul/src/lib.rs at line 456 [22.717381]

B:BD[26.61205] → [26.61205:61319]

    ) -> pristine::PathChangeset<'channel, 'txn, Self> {
        pristine::log_for_path(self, channel, pos, from)

[26.61205]

[26.61319]

    ) -> Result<pristine::PathChangeset<'channel, 'txn, Self>, Self::GraphError> {
        pristine::log_for_path(self, channel, pos, from).map_err(|e| e.0)

Replacement in libpijul/src/lib.rs at line 465 [22.717381]

B:BD[26.61511] → [26.61511:61632]

    ) -> pristine::RevPathChangeset<'channel, 'txn, Self> {
        pristine::rev_log_for_path(self, channel, pos, from)

[26.61511]

[22.730576]

    ) -> Result<pristine::RevPathChangeset<'channel, 'txn, Self>, Self::DepsError> {
        pristine::rev_log_for_path(self, channel, pos, from).map_err(|e| e.0)

Replacement in libpijul/src/lib.rs at line 473 [22.717381]

B:BD[22.730718] → [22.730718:730765]

    ) -> RevLog<'txn, Self> {
        RevLog {

[22.730718]

[22.730765]

    ) -> Result<RevLog<'txn, Self>, Self::GraphError> {
        Ok(RevLog {

Replacement in libpijul/src/lib.rs at line 476 [22.717381]

B:BD[22.730788] → [26.61633:61700]

∅:D[26.61700] → [22.730844:730854]

B:BD[22.730844] → [22.730844:730854]

            iter: pristine::changeid_rev_log(self, channel, from),
        }

[22.730788]

[22.730854]

            iter: pristine::changeid_rev_log(self, channel, from).map_err(|e| e.0)?,
        })

Replacement in libpijul/src/lib.rs at line 484 [22.717381]

B:BD[26.61826] → [26.61826:61985]

    ) -> pristine::RevCursor<
        Self,
        &'txn Self,
        Self::RevchangesetCursor,
        u64,
        (pristine::ChangeId, pristine::Merkle),

[26.61826]

[26.61985]

    ) -> Result<
        pristine::RevCursor<
            Self,
            &'txn Self,
            Self::RevchangesetCursor,
            u64,
            (pristine::ChangeId, pristine::Merkle),
        >,
        Self::GraphError,

Replacement in libpijul/src/lib.rs at line 494 [22.717381]

B:BD[26.61993] → [26.61993:62049]

        pristine::changeid_rev_log(self, channel, from)

[26.61993]

[26.62049]

        pristine::changeid_rev_log(self, channel, from).map_err(|e| e.0)

Replacement in libpijul/src/lib.rs at line 501 [22.717381]

B:BD[22.730958] → [22.730958:731143]

    ) -> Option<(pristine::Hash, pristine::Merkle)> {
        self.get_revchangeset(&channel.borrow().revchanges, n, None)
            .map(|(h, m)| (self.get_external(h).unwrap(), m))

[22.730958]

[22.731143]

    ) -> Result<Option<(pristine::Hash, pristine::Merkle)>, Self::GraphError> {
        if let Some((h, m)) = self
            .get_revchangeset(&channel.borrow().revchanges, n, None)
            .map_err(|e| e.0)?
        {
            Ok(Some((self.get_external(h).map_err(|e| e.0)?.unwrap(), m)))
        } else {
            Ok(None)
        }

Replacement in libpijul/src/lib.rs at line 516 [22.717381]

B:BD[22.731261] → [22.731261:731284]

B:BD[22.731284] → [26.62057:62122]

    ) -> Option<u64> {
        if let Some(h) = pristine::TxnT::get_internal(self, h) {

[22.731261]

[22.731332]

    ) -> Result<Option<u64>, Self::GraphError> {
        if let Some(h) = pristine::GraphTxnT::get_internal(self, h).map_err(|e| e.0)? {

Insertion in libpijul/src/lib.rs at line 519 [22.717381]
[22.731399]
[22.731399]
```
                .map_err(|e| e.0)
```
Replacement in libpijul/src/lib.rs at line 521 [22.717381]
B:BD[22.731416] → [22.731416:731433]
```
            None
```
[22.731416]
[22.731433]
```
            Ok(None)
```

Replacement in libpijul/src/lib.rs at line 525 [22.717381]

B:BD[22.731450] → [49.3034:3108]

∅:D[49.3108] → [26.62123:62189]

B:BD[22.731541] → [26.62123:62189]

∅:D[26.62189] → [22.731590:731617]

B:BD[22.731590] → [22.731590:731617]

    fn touched_files(&self, h: pristine::Hash) -> Option<Touched<Self>> {
        if let Some(id) = pristine::TxnT::get_internal(self, h) {
            Some(Touched {

[22.731450]

[22.731617]

    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)? {
            Ok(Some(Touched {

Replacement in libpijul/src/lib.rs at line 529 [22.717381]

B:BD[22.731644] → [22.731644:731705]

                iter: self.iter_rev_touched_files(id, None),

[22.731644]

[22.731705]

                iter: self.iter_rev_touched_files(id, None).map_err(|e| e.0)?,

Replacement in libpijul/src/lib.rs at line 531 [22.717381]
B:BD[22.731725] → [22.731725:731740]
```
            })
```
[22.731725]
[22.731740]
```
            }))
```
Replacement in libpijul/src/lib.rs at line 533 [22.717381]
B:BD[22.731757] → [22.731757:731774]
```
            None
```
[22.731757]
[22.731774]
```
            Ok(None)
```

Replacement in libpijul/src/lib.rs at line 542 [22.717381]

B:BD[22.731981] → [23.30000:30044]

    ) -> Result<(String, bool), C::Error> {

[22.731981]

[22.732030]

    ) -> Result<(String, bool), output::FileError<C::Error, Self::GraphError>> {

Replacement in libpijul/src/lib.rs at line 544 [22.717381]

B:BD[22.732074] → [26.62190:62272]

            change: pristine::TxnT::get_internal(self, position.change).unwrap(),

[22.732074]

[22.732139]

            change: pristine::GraphTxnT::get_internal(self, position.change)?.unwrap(),

Replacement in libpijul/src/lib.rs at line 555 [22.717381]

B:BD[22.732453] → [23.30045:30089]

    ) -> Result<(String, bool), C::Error> {

[22.732453]

[22.732502]

    ) -> Result<(String, bool), output::FileError<C::Error, Self::GraphError>> {

Replacement in libpijul/src/lib.rs at line 557 [22.717381]

B:BD[22.732546] → [26.62273:62355]

            change: pristine::TxnT::get_internal(self, position.change).unwrap(),

[22.732546]

[22.732611]

            change: pristine::GraphTxnT::get_internal(self, position.change)?.unwrap(),

Replacement in libpijul/src/lib.rs at line 568 [22.717381]

B:BD[22.732890] → [23.30090:30179]

∅:D[23.30179] → [22.732971:733032]

B:BD[22.732971] → [22.732971:733032]

    ) -> Result<(pristine::Position<pristine::ChangeId>, bool), fs::FsError<C::Error>> {
        fs::follow_oldest_path(changes, self, channel, path)

[22.732890]

[22.733032]

    ) -> Result<
        (pristine::Position<pristine::ChangeId>, bool),
        fs::FsErrorC<C::Error, Self::GraphError>,
    > {
        fs::follow_oldest_path(changes, self, &channel.borrow(), path)

Replacement in libpijul/src/lib.rs at line 581 [22.717381]

B:BD[22.733275] → [23.30180:30231]

    ) -> Result<(), output::FileError<C::Error>> {

[22.733275]

[22.733312]

    ) -> Result<(), output::FileError<C::Error, Self::GraphError>> {

Replacement in libpijul/src/lib.rs at line 584 [22.717381]

B:BD[22.733390] → [22.733390:733451]

        let mut graph = alive::retrieve(self, &channel, v0);

[22.733390]

[22.733451]

        let mut graph = alive::retrieve(self, &channel.graph, v0)?;

Replacement in libpijul/src/lib.rs at line 594 [22.717381]

B:BD[22.733724] → [23.30232:30328]

    ) -> Result<Vec<output::Conflict>, output::ArchiveError<C::Error, Self::Error, A::Error>> {

[22.733724]

[22.733780]

    ) -> Result<Vec<output::Conflict>, output::ArchiveError<C::Error, Self::GraphError, A::Error>>
    {

Replacement in libpijul/src/lib.rs at line 605 [22.717381]

B:BD[22.734091] → [23.30329:30425]

    ) -> Result<Vec<output::Conflict>, output::ArchiveError<C::Error, Self::Error, A::Error>> {

[22.734091]

[22.734147]

    ) -> Result<Vec<output::Conflict>, output::ArchiveError<C::Error, Self::GraphError, A::Error>>
    {

Replacement in libpijul/src/lib.rs at line 612 [22.717381]
B:BD[26.62415] → [26.62415:62462]
```
        channel: &'db pristine::Channel<Self>,
```
[26.62415]
[26.62462]
```
        graph: &'db pristine::Channel<Self>,
```

Replacement in libpijul/src/lib.rs at line 616 [22.717381]

B:BD[26.62581] → [26.62581:62703]

    ) -> pristine::AdjacentIterator<'txn, Self> {
        pristine::iter_adjacent(self, channel, key, min_flag, max_flag)

[26.62581]

[26.62703]

    ) -> Result<pristine::AdjacentIterator<'txn, Self>, pristine::TxnErr<Self::GraphError>> {
        pristine::iter_adjacent(self, &graph.graph, key, min_flag, max_flag)

Replacement in libpijul/src/lib.rs at line 621 [22.717381]
B:BD[22.734218] → [22.734218:734260]
```
pub struct Log<'txn, T: pristine::TxnT> {
```
[22.734218]
[22.734260]
```
pub struct Log<'txn, T: pristine::ChannelTxnT> {
```

Replacement in libpijul/src/lib.rs at line 632 [22.717381]

B:BD[22.734436] → [22.734436:734553]

impl<'txn, T: pristine::TxnT> Iterator for Log<'txn, T> {
    type Item = (u64, (pristine::Hash, pristine::Merkle));

[22.734436]

[22.734553]

impl<'txn, T: pristine::ChannelTxnT> Iterator for Log<'txn, T> {
    type Item = Result<(u64, (pristine::Hash, pristine::Merkle)), T::GraphError>;

Replacement in libpijul/src/lib.rs at line 635 [22.717381]

B:BD[22.734600] → [22.734600:734714]

        self.iter
            .next()
            .map(|(n, (c, m))| (n, (self.txn.get_external(c).unwrap(), m)))

[22.734600]

[22.734714]

        match self.iter.next() {
            Some(Ok((n, (c, m)))) => {
                let ext = match self.txn.get_external(c) {
                    Err(pristine::TxnErr(e)) => return Some(Err(e)),
                    Ok(Some(ext)) => ext,
                    Ok(None) => panic!("Unknown change {:?}", c),
                };
                Some(Ok((n, (ext, m))))
            }
            None => None,
            Some(Err(e)) => Some(Err(e.0)),
        }

Replacement in libpijul/src/lib.rs at line 650 [22.717381]
B:BD[22.734723] → [22.734723:734768]
```
pub struct RevLog<'txn, T: pristine::TxnT> {
```
[22.734723]
[22.734768]
```
pub struct RevLog<'txn, T: pristine::ChannelTxnT> {
```

Replacement in libpijul/src/lib.rs at line 661 [22.717381]

B:BD[22.734947] → [22.734947:735067]

impl<'txn, T: pristine::TxnT> Iterator for RevLog<'txn, T> {
    type Item = (u64, (pristine::Hash, pristine::Merkle));

[22.734947]

[22.735067]

impl<'txn, T: pristine::ChannelTxnT> Iterator for RevLog<'txn, T> {
    type Item = Result<(u64, (pristine::Hash, pristine::Merkle)), T::GraphError>;

Replacement in libpijul/src/lib.rs at line 664 [22.717381]

B:BD[22.735114] → [22.735114:735228]

        self.iter
            .next()
            .map(|(n, (c, m))| (n, (self.txn.get_external(c).unwrap(), m)))

[22.735114]

[22.735228]

        match self.iter.next() {
            Some(Ok((n, (c, m)))) => match self.txn.get_external(c) {
                Ok(Some(ext)) => Some(Ok((n, (ext, m)))),
                Err(e) => Some(Err(e.0)),
                Ok(None) => panic!("Unknown change {:?}", c),
            },
            None => None,
            Some(Err(e)) => Some(Err(e.0)),
        }

Replacement in libpijul/src/lib.rs at line 676 [22.717381]
B:BD[22.735237] → [22.735237:735283]
```
pub struct Touched<'txn, T: pristine::TxnT> {
```
[22.735237]
[22.735283]
```
pub struct Touched<'txn, T: pristine::DepsTxnT> {
```

Replacement in libpijul/src/lib.rs at line 688 [22.717381]

B:BD[22.735507] → [22.735507:735621]

impl<'txn, T: pristine::TxnT> Iterator for Touched<'txn, T> {
    type Item = pristine::Position<pristine::Hash>;

[22.735507]

[22.735621]

impl<
        'txn,
        T: pristine::DepsTxnT + pristine::GraphTxnT<GraphError = <T as pristine::DepsTxnT>::DepsError>,
    > Iterator for Touched<'txn, T>
{
    type Item = Result<pristine::Position<pristine::Hash>, T::DepsError>;

Replacement in libpijul/src/lib.rs at line 695 [22.717381]

B:BD[22.735668] → [22.735668:735725]

        while let Some((cid, file)) = self.iter.next() {

[22.735668]

[22.735725]

        while let Some(x) = self.iter.next() {
            let (cid, file) = match x {
                Ok(x) => x,
                Err(e) => return Some(Err(e.0)),
            };

Replacement in libpijul/src/lib.rs at line 703 [22.717381]

B:BD[22.735824] → [22.735824:735947]

                let change = self.txn.get_external(file.change).unwrap();
                return Some(pristine::Position {

[22.735824]

[22.735947]

                let change = match self.txn.get_external(file.change) {
                    Ok(ext) => ext.unwrap(),
                    Err(e) => return Some(Err(e.0)),
                };
                return Some(Ok(pristine::Position {

Replacement in libpijul/src/lib.rs at line 710 [22.717381]
B:BD[22.736010] → [22.736010:736030]
```
                });
```
[22.736010]
[22.736030]
```
                }));
```

Replacement in libpijul/src/fs.rs at line 25 [22.737429]

B:BD[23.30501] → [23.30501:30559]

    #[error("Path not found: {0}")]
    NotFound(String),

[23.30501]

[23.30559]

    #[error(transparent)]
    NotFound(#[from] FsNotFound),

Insertion in libpijul/src/fs.rs at line 29 [22.737429]

[23.30634]

    #[error(transparent)]
    Txn(T),
}
#[derive(Debug, Error)]
pub enum FsErrorC<C: std::error::Error + 'static, T: std::error::Error + 'static> {

Insertion in libpijul/src/fs.rs at line 37 [22.737429]

[23.30672]

    #[error(transparent)]
    Changestore(C),
    #[error(transparent)]
    NotFound(#[from] FsNotFound),
}
#[derive(Debug, Error)]
#[error("Path not found: {0}")]
pub struct FsNotFound(String);
impl<T: std::error::Error + 'static> std::convert::From<TxnErr<T>> for FsError<T> {
    fn from(e: TxnErr<T>) -> Self {
        FsError::Txn(e.0)
    }
}
impl<C: std::error::Error + 'static, T: std::error::Error + 'static> std::convert::From<TxnErr<T>>
    for FsErrorC<C, T>
{
    fn from(e: TxnErr<T>) -> Self {
        FsErrorC::Txn(e.0)
    }

Replacement in libpijul/src/fs.rs at line 61 [22.737429]
∅:D[60.1] → [22.738541:738608]
∅:D[23.30675] → [22.738541:738608]
B:BD[22.738541] → [22.738541:738608]
```
pub(crate) fn create_new_inode<T: MutTxnT>(txn: &mut T) -> Inode {
```
[23.30675]
[22.738608]
```
pub(crate) fn create_new_inode<T: TreeMutTxnT>(txn: &mut T) -> Result<Inode, TxnErr<T::TreeError>> {
```

Replacement in libpijul/src/fs.rs at line 66 [22.737429]

B:BD[22.738741] → [22.738741:738805]

        already_taken = txn.get_revtree(inode, None).is_some();

[22.738741]

[22.738805]

        already_taken = txn.get_revtree(inode, None)?.is_some();

Replacement in libpijul/src/fs.rs at line 68 [22.737429]
B:BD[22.738811] → [22.738811:738821]
```
    inode
```
[22.738811]
[22.738821]
```
    Ok(inode)
```

Replacement in libpijul/src/fs.rs at line 73 [22.737429]

B:BD[22.738959] → [22.738959:739021]

pub fn is_directory<T: TxnT>(txn: &T, inode: Inode) -> bool {

[22.738959]

[22.739021]

pub fn is_directory<T: TreeTxnT>(txn: &T, inode: Inode) -> Result<bool, TxnErr<T::TreeError>> {

Replacement in libpijul/src/fs.rs at line 75 [22.737429]
B:BD[22.739051] → [22.739051:739072]
```
        return true;
```
[22.739051]
[22.739072]
```
        return Ok(true);
```

Replacement in libpijul/src/fs.rs at line 81 [22.737429]

B:BD[22.739183] → [22.739183:739241]

    for (pid, _) in txn.iter_tree(pathid.clone(), None) {

[22.739183]

[22.739241]

    for x in txn.iter_tree(pathid.clone(), None)? {
        let (pid, _) = x?;

Replacement in libpijul/src/fs.rs at line 88 [22.737429]
B:BD[22.739351] → [22.739351:739372]
```
        return true;
```
[22.739351]
[22.739372]
```
        return Ok(true);
```
Replacement in libpijul/src/fs.rs at line 90 [22.737429]
B:BD[22.739378] → [22.739378:739388]
```
    false
```
[22.739378]
[22.739388]
```
    Ok(false)
```
Replacement in libpijul/src/fs.rs at line 93 [22.737429]
∅:D[60.5] → [22.739445:739487]
B:BD[22.739445] → [22.739445:739487]
```
fn closest_in_repo_ancestor<'a, T: TxnT>(
```
[60.5]
[22.739487]
```
fn closest_in_repo_ancestor<'a, T: TreeTxnT>(
```

Replacement in libpijul/src/fs.rs at line 96 [22.737429]

B:BD[22.739519] → [22.739519:739584]

) -> (Inode, std::iter::Peekable<crate::path::Components<'a>>) {

[22.739519]

[22.739584]

) -> Result<(Inode, std::iter::Peekable<crate::path::Components<'a>>), TxnErr<T::TreeError>> {

Replacement in libpijul/src/fs.rs at line 107 [22.737429]

B:BD[22.739962] → [22.739962:740027]

        for (id, inode) in txn.iter_tree(fileid.clone(), None) {

[22.739962]

[22.740027]

        for x in txn.iter_tree(fileid.clone(), None)? {
            let (id, inode) = x?;

Replacement in libpijul/src/fs.rs at line 130 [22.737429]
B:BD[22.740541] → [22.740541:740579]
```
    (fileid.parent_inode, components)
```
[22.740541]
[22.740579]
```
    Ok((fileid.parent_inode, components))
```

Replacement in libpijul/src/fs.rs at line 134 [22.737429]

B:BD[23.30737] → [23.30737:30823]

pub fn find_inode<T: TxnT>(txn: &T, path: &str) -> Result<Inode, FsError<T::Error>> {

[23.30737]

[22.740814]

pub fn find_inode<T: TreeTxnT>(txn: &T, path: &str) -> Result<Inode, FsError<T::TreeError>> {

Replacement in libpijul/src/fs.rs at line 136 [22.737429]

B:BD[22.740840] → [22.740840:740926]

    let (inode, mut remaining_path_components) = closest_in_repo_ancestor(txn, path);

[22.740840]

[22.740926]

    let (inode, mut remaining_path_components) = closest_in_repo_ancestor(txn, path)?;

Replacement in libpijul/src/fs.rs at line 140 [22.737429]
B:BD[22.741040] → [23.30824:30873]
```
        Err(FsError::NotFound(path.to_string()))
```
[22.741040]
[22.741140]
```
        Err(FsNotFound(path.to_string()).into())
```

Replacement in libpijul/src/fs.rs at line 147 [22.737429]

B:BD[22.741242] → [22.741242:741300]

pub fn is_tracked<T: TxnT>(txn: &T, path: &str) -> bool {

[22.741242]

[22.741300]

pub fn is_tracked<T: TreeTxnT>(txn: &T, path: &str) -> Result<bool, TxnErr<T::TreeError>> {

Replacement in libpijul/src/fs.rs at line 149 [22.737429]

B:BD[22.741337] → [22.741337:741419]

    let (_, mut remaining_path_components) = closest_in_repo_ancestor(txn, path);

[22.741337]

[22.741419]

    let (_, mut remaining_path_components) = closest_in_repo_ancestor(txn, path)?;

Replacement in libpijul/src/fs.rs at line 151 [22.737429]
B:BD[22.741457] → [22.741457:741504]
```
    remaining_path_components.next().is_none()
```
[22.741457]
[22.741504]
```
    Ok(remaining_path_components.next().is_none())
```

Replacement in libpijul/src/fs.rs at line 155 [22.737429]

B:BD[22.741617] → [22.741617:741691]

pub fn inode_filename<T: TxnT>(txn: &T, inode: Inode) -> Option<String> {

[22.741617]

[22.741691]

pub fn inode_filename<T: TreeTxnT>(
    txn: &T,
    inode: Inode,
) -> Result<Option<String>, TxnErr<T::TreeError>> {

Replacement in libpijul/src/fs.rs at line 162 [22.737429]
B:BD[22.741768] → [22.741768:741815]
```
        match txn.get_revtree(current, None) {
```
[22.741768]
[22.741815]
```
        match txn.get_revtree(current, None)? {
```
Replacement in libpijul/src/fs.rs at line 172 [22.737429]
B:BD[22.742118] → [22.742118:742147]
```
                return None;
```
[22.742118]
[22.742147]
```
                return Ok(None);
```
Replacement in libpijul/src/fs.rs at line 184 [22.737429]
B:BD[22.742417] → [22.742417:742432]
```
    Some(path)
```
[22.742417]
[22.742432]
```
    Ok(Some(path))
```
Replacement in libpijul/src/fs.rs at line 189 [22.737429]
B:BD[22.742616] → [22.742616:742647]
```
fn make_new_child<T: MutTxnT>(
```
[22.742616]
[22.742647]
```
fn make_new_child<T: TreeMutTxnT>(
```
Replacement in libpijul/src/fs.rs at line 195 [22.737429]
B:BD[22.742759] → [23.30874:30914]
```
) -> Result<Inode, FsError<T::Error>> {
```
[22.742759]
[22.742795]
```
) -> Result<Inode, FsError<T::TreeError>> {
```

Replacement in libpijul/src/fs.rs at line 201 [22.737429]

∅:D[60.15] → [22.742982:743052]

B:BD[22.742982] → [22.742982:743052]

    if let Some(inode) = txn.get_tree(parent_id.as_file_id(), None) {

[60.15]

[22.743052]

    if let Some(inode) = txn.get_tree(parent_id.as_file_id(), None)? {

Replacement in libpijul/src/fs.rs at line 208 [22.737429]

B:BD[22.743256] → [23.30915:31009]

∅:D[41.2896] → [22.743414:743482]

∅:D[23.31009] → [22.743414:743482]

B:BD[22.743414] → [22.743414:743482]

B:BD[22.743482] → [23.31010:31094]

                del_tree_with_rev(txn, parent_id.as_file_id(), inode).map_err(FsError::Txn)?;
                if let Some(vertex) = txn.get_inodes(inode, None) {
                    del_inodes_with_rev(txn, inode, vertex).map_err(FsError::Txn)?;

[22.743256]

[22.743619]

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

Replacement in libpijul/src/fs.rs at line 212 [22.737429]

B:BD[22.743637] → [23.31095:31189]

                put_tree_with_rev(txn, parent_id.as_file_id(), child).map_err(FsError::Txn)?;

[22.743637]

[22.743764]

                put_tree_with_rev(txn, parent_id.as_file_id(), child)?;

Replacement in libpijul/src/fs.rs at line 220 [22.737429]
B:BD[22.744073] → [22.744073:744116]
```
            None => create_new_inode(txn),
```
[22.744073]
[22.744116]
```
            None => create_new_inode(txn)?,
```

Replacement in libpijul/src/fs.rs at line 224 [22.737429]

B:BD[22.744222] → [23.31253:31345]

        put_tree_with_rev(txn, parent_id.as_file_id(), child_inode).map_err(FsError::Txn)?;

[22.744222]

[22.744345]

        put_tree_with_rev(txn, parent_id.as_file_id(), child_inode)?;

Replacement in libpijul/src/fs.rs at line 231 [22.737429]

B:BD[22.744509] → [23.31346:31446]

            txn.put_tree(dir_id.as_file_id(), child_inode)
                .map_err(FsError::Txn)?;

[22.744509]

[22.744570]

            txn.put_tree(dir_id.as_file_id(), child_inode)?;

Replacement in libpijul/src/fs.rs at line 237 [22.737429]
∅:D[60.17] → [22.744668:744705]
B:BD[22.744668] → [22.744668:744705]
```
pub(crate) fn add_inode<T: MutTxnT>(
```
[60.17]
[22.744705]
```
pub(crate) fn add_inode<T: TreeMutTxnT>(
```
Replacement in libpijul/src/fs.rs at line 242 [22.737429]
B:BD[22.744782] → [23.31447:31484]
```
) -> Result<(), FsError<T::Error>> {
```
[22.744782]
[22.744815]
```
) -> Result<(), FsError<T::TreeError>> {
```

Replacement in libpijul/src/fs.rs at line 245 [22.737429]

B:BD[22.744894] → [22.744894:744980]

        let (current_inode, unrecorded_path) = closest_in_repo_ancestor(txn, parent);

[22.744894]

[22.744980]

        let (current_inode, unrecorded_path) = closest_in_repo_ancestor(txn, parent)?;

Replacement in libpijul/src/fs.rs at line 264 [22.737429]
B:BD[22.745758] → [22.745758:745788]
```
pub fn move_file<T: MutTxnT>(
```
[22.745758]
[22.745788]
```
pub fn move_file<T: TreeMutTxnT>(
```
Replacement in libpijul/src/fs.rs at line 268 [22.737429]
B:BD[22.745846] → [23.31485:31522]
```
) -> Result<(), FsError<T::Error>> {
```
[22.745846]
[22.745879]
```
) -> Result<(), FsError<T::TreeError>> {
```
Replacement in libpijul/src/fs.rs at line 274 [22.737429]
B:BD[22.746015] → [22.746015:746054]
```
pub fn move_file_by_inode<T: MutTxnT>(
```
[22.746015]
[22.746054]
```
pub fn move_file_by_inode<T: TreeMutTxnT>(
```

Replacement in libpijul/src/fs.rs at line 278 [22.737429]

B:BD[22.746112] → [23.31523:31560]

∅:D[23.31560] → [22.746145:746213]

B:BD[22.746145] → [22.746145:746213]

) -> Result<(), FsError<T::Error>> {
    let fileref = txn.get_revtree(inode, None).unwrap().to_owned();

[22.746112]

[22.746213]

) -> Result<(), FsError<T::TreeError>> {
    let fileref = txn.get_revtree(inode, None)?.unwrap().to_owned();

Replacement in libpijul/src/fs.rs at line 281 [22.737429]

B:BD[22.746252] → [23.31561:31641]

    del_tree_with_rev(txn, fileref.as_file_id(), inode).map_err(FsError::Txn)?;

[22.746252]

[22.746499]

    del_tree_with_rev(txn, fileref.as_file_id(), inode)?;

Replacement in libpijul/src/fs.rs at line 291 [22.737429]
B:BD[22.746770] → [22.746770:746780]
```
        )
```
[22.746770]
[22.746780]
```
        )?
```
Replacement in libpijul/src/fs.rs at line 297 [22.737429]
∅:D[60.21] → [22.746923:746961]
B:BD[22.746923] → [22.746923:746961]
```
pub(crate) fn rec_delete<T: MutTxnT>(
```
[60.21]
[22.746961]
```
pub(crate) fn rec_delete<T: TreeMutTxnT>(
```
Replacement in libpijul/src/fs.rs at line 301 [22.737429]
B:BD[22.747046] → [23.31642:31679]
```
) -> Result<(), FsError<T::Error>> {
```
[22.747021]
[22.747079]
```
) -> Result<(), FsError<T::TreeError>> {
```

Replacement in libpijul/src/fs.rs at line 308 [22.737429]

B:BD[22.747248] → [22.747248:747309]

    for (k, inode) in txn.iter_tree(file_id.clone(), None) {

[22.747248]

[22.747309]

    for x in txn.iter_tree(file_id.clone(), None)? {
        let (k, inode) = x?;

Replacement in libpijul/src/fs.rs at line 330 [22.737429]

B:BD[51.67] → [10.0:188]

        assert!(
            inode.is_root()
                || txn
                    .del_tree(file_id.as_file_id(), Some(inode))
                    .map_err(FsError::Txn)?
        );

[51.67]

[22.748177]

        assert!(inode.is_root() || txn.del_tree(file_id.as_file_id(), Some(inode))?);

Replacement in libpijul/src/fs.rs at line 332 [22.737429]

B:BD[22.748183] → [10.189:304]

∅:D[10.304] → [41.3292:3352]

∅:D[23.31879] → [41.3292:3352]

B:BD[41.3292] → [41.3292:3352]

B:BD[41.3352] → [23.31880:31956]

    if !inode.is_root()
        && del_tree_with_rev(txn, parent.as_file_id(), inode).map_err(FsError::Txn)?
    {
        if let Some(vertex) = txn.get_inodes(inode, None) {
            del_inodes_with_rev(txn, inode, vertex).map_err(FsError::Txn)?;

[22.748183]

[22.748543]

    if !inode.is_root() && del_tree_with_rev(txn, parent.as_file_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 347 [22.737429]

B:BD[22.748753] → [23.31957:32048]

pub fn remove_file<T: MutTxnT>(txn: &mut T, path: &str) -> Result<(), FsError<T::Error>> {

[22.748753]

[22.748840]

pub fn remove_file<T: TreeMutTxnT>(txn: &mut T, path: &str) -> Result<(), FsError<T::TreeError>> {

Replacement in libpijul/src/fs.rs at line 356 [22.737429]

B:BD[10.469] → [10.469:526]

        txn.get_revtree(inode, None).unwrap().to_owned()

[10.469]

[10.526]

        txn.get_revtree(inode, None)?.unwrap().to_owned()

Replacement in libpijul/src/fs.rs at line 368 [22.737429]
B:BD[22.749331] → [22.749331:749379]
```
pub struct WorkingCopyChildren<'txn, T: TxnT> {
```
[22.749331]
[22.749379]
```
pub struct WorkingCopyChildren<'txn, T: TreeTxnT> {
```

Replacement in libpijul/src/fs.rs at line 373 [22.737429]

B:BD[22.749482] → [22.749482:749584]

impl<'txn, T: TxnT> Iterator for WorkingCopyChildren<'txn, T> {
    type Item = (SmallString, Inode);

[22.749482]

[22.749584]

impl<'txn, T: TreeTxnT> Iterator for WorkingCopyChildren<'txn, T> {
    type Item = Result<(SmallString, Inode), T::TreeError>;

Replacement in libpijul/src/fs.rs at line 377 [22.737429]

B:BD[22.749646] → [22.749646:749849]

            if let Some((k, v)) = self.iter.next() {
                if k.parent_inode == self.inode {
                    if k.basename.len() > 0 {
                        return Some((k.basename, v));

[22.749646]

[22.749849]

            match self.iter.next() {
                Some(Ok((k, v))) => {
                    if k.parent_inode == self.inode {
                        if k.basename.len() > 0 {
                            return Some(Ok((k.basename, v)));
                        }
                    } else if k.parent_inode > self.inode {
                        return None;

Deletion in libpijul/src/fs.rs at line 386 [22.737429]

B:BD[22.749871] → [22.749871:749960]

                } else if k.parent_inode > self.inode {
                    return None;

Replacement in libpijul/src/fs.rs at line 387 [22.737429]

B:BD[22.749978] → [22.749978:750028]

            } else {
                return None;

[22.749978]

[22.750028]

                None => return None,
                Some(Err(e)) => return Some(Err(e.0)),

Replacement in libpijul/src/fs.rs at line 395 [22.737429]

B:BD[22.750130] → [49.3167:3256]

∅:D[49.3256] → [22.750247:750455]

B:BD[22.750247] → [22.750247:750455]

pub fn working_copy_children<T: TxnT>(txn: &T, inode: Inode) -> WorkingCopyChildren<T> {
    WorkingCopyChildren {
        iter: txn.iter_tree(
            OwnedPathId {
                parent_inode: inode,
                basename: SmallString::new(),
            },
            None,
        ),

[22.750130]

[22.750455]

pub fn working_copy_children<T: TreeTxnT>(
    txn: &T,
    inode: Inode,
) -> Result<WorkingCopyChildren<T>, T::TreeError> {
    Ok(WorkingCopyChildren {
        iter: txn
            .iter_tree(
                OwnedPathId {
                    parent_inode: inode,
                    basename: SmallString::new(),
                },
                None,
            )
            .map_err(|e| e.0)?,

Replacement in libpijul/src/fs.rs at line 410 [22.737429]
B:BD[22.750470] → [22.750470:750476]
```
    }
```
[22.750470]
[22.750476]
```
    })
```
Replacement in libpijul/src/fs.rs at line 416 [22.737429]
B:BD[22.750665] → [22.750665:750713]
```
pub struct WorkingCopyIterator<'txn, T: TxnT> {
```
[22.750665]
[22.750713]
```
pub struct WorkingCopyIterator<'txn, T: TreeTxnT> {
```

Replacement in libpijul/src/fs.rs at line 421 [22.737429]

B:BD[22.750767] → [22.750767:750864]

impl<'txn, T: TxnT> Iterator for WorkingCopyIterator<'txn, T> {
    type Item = (Inode, String);

[22.750767]

[22.750864]

impl<'txn, T: TreeTxnT> Iterator for WorkingCopyIterator<'txn, T> {
    type Item = Result<(Inode, String), T::TreeError>;

Replacement in libpijul/src/fs.rs at line 431 [22.737429]

∅:D[6.44] → [22.751146:751211]

B:BD[22.751146] → [22.751146:751211]

                for (k, v) in self.txn.iter_tree(fileid, None) {

[6.44]

[22.751211]

                let iter = match self.txn.iter_tree(fileid, None) {
                    Ok(iter) => iter,
                    Err(e) => return Some(Err(e.0)),
                };
                for x in iter {
                    let (k, v) = match x {
                        Ok(x) => x,
                        Err(e) => return Some(Err(e.0)),
                    };

Replacement in libpijul/src/fs.rs at line 453 [22.737429]

B:BD[22.751704] → [22.751704:751752]

                    return Some((inode, name));

[22.751704]

[22.751752]

                    return Some(Ok((inode, name)));

Replacement in libpijul/src/fs.rs at line 463 [22.737429]

B:BD[22.751917] → [49.3257:3341]

pub fn iter_working_copy<T: TxnT>(txn: &T, root: Inode) -> WorkingCopyIterator<T> {

[22.751917]

[22.752018]

pub fn iter_working_copy<T: TreeTxnT>(txn: &T, root: Inode) -> WorkingCopyIterator<T> {

Replacement in libpijul/src/fs.rs at line 475 [22.737429]

B:BD[28.13264] → [28.13264:13319]

pub struct GraphDescendants<'txn, 'channel, T: TxnT> {

[28.13264]

[28.13319]

pub struct GraphDescendants<'txn, 'channel, T: GraphTxnT> {

Replacement in libpijul/src/fs.rs at line 477 [22.737429]
B:BD[28.13337] → [28.13337:13372]
```
    channel: &'channel Channel<T>,
```
[28.13337]
[28.13372]
```
    channel: &'channel T::Graph,
```

Replacement in libpijul/src/fs.rs at line 482 [22.737429]

B:BD[22.752110] → [28.13458:13575]

impl<'txn, 'channel, T: TxnT> Iterator for GraphDescendants<'txn, 'channel, T> {
    type Item = Position<ChangeId>;

[22.752110]

[28.13575]

impl<'txn, 'channel, T: GraphTxnT> Iterator for GraphDescendants<'txn, 'channel, T> {
    type Item = Result<Position<ChangeId>, T::GraphError>;

Replacement in libpijul/src/fs.rs at line 486 [22.737429]

B:BD[28.13672] → [28.13672:14276]

            if let Some(child) = adj.next() {
                self.stack.push(adj);
                let dest = find_block(self.txn, &self.channel, child.dest).unwrap();
                let grandchild = iter_adjacent(
                    self.txn,
                    &self.channel,
                    dest,
                    EdgeFlags::FOLDER,
                    EdgeFlags::FOLDER | EdgeFlags::PSEUDO | EdgeFlags::BLOCK,
                )
                .next()
                .unwrap();
                if self.visited.insert(grandchild.dest) {
                    self.stack.push(iter_adjacent(

[28.13672]

[28.14276]

            match adj.next() {
                Some(Ok(child)) => {
                    self.stack.push(adj);
                    let dest = match find_block(self.txn, self.channel, child.dest) {
                        Ok(dest) => dest,
                        Err(BlockError::Txn(t)) => return Some(Err(t)),
                        Err(e) => panic!("{}", e),
                    };
                    let grandchild = match iter_adjacent(

Replacement in libpijul/src/fs.rs at line 496 [22.737429]

B:BD[28.14310] → [28.14310:14405]

                        &self.channel,
                        grandchild.dest.inode_vertex(),

[28.14310]

[28.14405]

                        self.channel,
                        dest,

Replacement in libpijul/src/fs.rs at line 500 [22.737429]

B:BD[28.14530] → [28.14530:14553]

))

[28.14530]

[28.14553]

                    ) {
                        Ok(mut x) => match x.next().unwrap() {
                            Ok(x) => x,
                            Err(e) => return Some(Err(e.0)),
                        },
                        Err(e) => return Some(Err(e.0)),
                    };
                    if self.visited.insert(grandchild.dest) {
                        match iter_adjacent(
                            self.txn,
                            self.channel,
                            grandchild.dest.inode_vertex(),
                            EdgeFlags::FOLDER,
                            EdgeFlags::FOLDER | EdgeFlags::PSEUDO | EdgeFlags::BLOCK,
                        ) {
                            Ok(adj) => self.stack.push(adj),
                            Err(e) => return Some(Err(e.0)),
                        }
                    }
                    return Some(Ok(grandchild.dest));

Replacement in libpijul/src/fs.rs at line 522 [22.737429]

B:BD[28.14571] → [28.14571:14686]

                return Some(grandchild.dest);
            } else {
                // No child left, actually pop.

[28.14571]

[28.14686]

                Some(Err(e)) => return Some(Err(e.0)),
                None => {
                    // No child left, actually pop.
                }

Replacement in libpijul/src/fs.rs at line 534 [22.737429]

B:BD[28.14870] → [28.14870:14926]

pub fn iter_graph_descendants<'txn, 'channel, T: TxnT>(

[28.14870]

[28.14926]

pub fn iter_graph_descendants<'txn, 'channel, T: GraphTxnT>(

Replacement in libpijul/src/fs.rs at line 536 [22.737429]
B:BD[28.14944] → [28.14944:14979]
```
    channel: &'channel Channel<T>,
```
[28.14944]
[28.14979]
```
    channel: &'channel T::Graph,
```

Replacement in libpijul/src/fs.rs at line 538 [22.737429]

B:BD[28.15008] → [28.15008:15074]

) -> GraphDescendants<'txn, 'channel, T> {
    GraphDescendants {

[28.15008]

[28.15074]

) -> Result<GraphDescendants<'txn, 'channel, T>, T::GraphError> {
    Ok(GraphDescendants {

Replacement in libpijul/src/fs.rs at line 546 [22.737429]
B:BD[28.15281] → [28.15281:15293]
```
        )],
```
[28.15281]
[28.15293]
```
        )
        .map_err(|e| e.0)?],
```
Replacement in libpijul/src/fs.rs at line 551 [22.737429]
B:BD[28.15356] → [28.15356:15362]
```
    }
```
[28.15356]
[28.15362]
```
    })
```

Replacement in libpijul/src/fs.rs at line 559 [22.737429]

B:BD[22.752344] → [22.752344:752433]

pub struct GraphChildren<'txn, 'channel, 'changes, T: TxnT, P: ChangeStore + 'changes> {

[22.752344]

[22.752433]

pub struct GraphChildren<'txn, 'channel, 'changes, T: GraphTxnT, P: ChangeStore + 'changes> {

Replacement in libpijul/src/fs.rs at line 561 [22.737429]
B:BD[22.752451] → [22.752451:752486]
```
    channel: &'channel Channel<T>,
```
[22.752451]
[22.752486]
```
    channel: &'channel T::Graph,
```

Replacement in libpijul/src/fs.rs at line 567 [22.737429]

B:BD[22.752569] → [22.752569:752645]

impl<'txn, 'channel, 'changes, T: TxnT, P: ChangeStore + 'changes> Iterator

[22.752569]

[22.752645]

impl<'txn, 'channel, 'changes, T: GraphTxnT, P: ChangeStore + 'changes> Iterator

Replacement in libpijul/src/fs.rs at line 570 [22.737429]

B:BD[22.752701] → [22.752701:752762]

    type Item = (Position<ChangeId>, InodeMetadata, String);

[22.752701]

[22.752762]

    type Item = Result<(Position<ChangeId>, InodeMetadata, String), T::GraphError>;

Replacement in libpijul/src/fs.rs at line 572 [22.737429]

B:BD[22.752809] → [22.752809:752852]

B:BD[22.752852] → [26.62710:62791]

∅:D[26.62791] → [22.752932:753346]

B:BD[22.752932] → [22.752932:753346]

        self.adj.next().map(move |child| {
            let dest = find_block(self.txn, &self.channel, child.dest).unwrap();
            let mut buf = std::mem::replace(&mut self.buf, Vec::new());
            self.changes
                .get_contents(|p| self.txn.get_external(p), dest, &mut buf)
                .unwrap();
            self.buf = buf;
            let (perms, basename) = self.buf.split_at(2);
            let perms = InodeMetadata::from_basename(perms);
            let basename = std::str::from_utf8(basename).unwrap();

[22.752809]

[22.753346]

        let child = match self.adj.next()? {
            Ok(child) => child,
            Err(e) => return Some(Err(e.0)),
        };
        let dest = find_block(self.txn, self.channel, child.dest).unwrap();
        let mut buf = std::mem::replace(&mut self.buf, Vec::new());
        self.changes
            .get_contents(|p| self.txn.get_external(p).unwrap(), dest, &mut buf)
            .unwrap();
        self.buf = buf;
        let (perms, basename) = self.buf.split_at(2);
        let perms = InodeMetadata::from_basename(perms);
        let basename = std::str::from_utf8(basename).unwrap();

Replacement in libpijul/src/fs.rs at line 586 [22.737429]

B:BD[22.753347] → [26.62792:62950]

B:BD[26.62950] → [26.62950:63024]

B:BD[26.63024] → [26.63024:63081]

∅:D[26.63081] → [22.753681:753751]

B:BD[22.753681] → [22.753681:753751]

            let grandchild = iter_adjacent(
                self.txn,
                &self.channel,
                dest,
                EdgeFlags::FOLDER,
                EdgeFlags::FOLDER | EdgeFlags::PSEUDO | EdgeFlags::BLOCK,
            )
            .next()
            .unwrap();
            (grandchild.dest, perms, basename.to_string())
        })

[22.753347]

[22.753751]

        let grandchild = match iter_adjacent(
            self.txn,
            self.channel,
            dest,
            EdgeFlags::FOLDER,
            EdgeFlags::FOLDER | EdgeFlags::PSEUDO | EdgeFlags::BLOCK,
        ) {
            Ok(mut adj) => match adj.next() {
                Some(Ok(n)) => n,
                None => unreachable!(),
                Some(Err(e)) => return Some(Err(e.0)),
            },
            Err(e) => return Some(Err(e.0)),
        };
        Some(Ok((grandchild.dest, perms, basename.to_string())))

Replacement in libpijul/src/fs.rs at line 609 [22.737429]
B:BD[22.754002] → [22.754002:754037]
```
    channel: &'channel Channel<T>,
```
[22.754002]
[22.754037]
```
    channel: &'channel T::Graph,
```

Replacement in libpijul/src/fs.rs at line 611 [22.737429]

B:BD[22.754066] → [22.754066:754117]

) -> GraphChildren<'txn, 'channel, 'changes, T, P>

[22.754066]

[22.754117]

) -> Result<GraphChildren<'txn, 'channel, 'changes, T, P>, T::GraphError>

Replacement in libpijul/src/fs.rs at line 613 [22.737429]
B:BD[22.754123] → [22.754123:754136]
```
    T: TxnT,
```
[22.754123]
[22.754136]
```
    T: GraphTxnT,
```
Replacement in libpijul/src/fs.rs at line 616 [22.737429]
B:BD[22.754158] → [22.754158:754178]
```
    GraphChildren {
```
[22.754158]
[22.754178]
```
    Ok(GraphChildren {
```
Replacement in libpijul/src/fs.rs at line 620 [22.737429]
∅:D[26.63127] → [22.754235:754257]
B:BD[22.754235] → [22.754235:754257]
```
            &channel,
```
[26.63127]
[22.754257]
```
            channel,
```
Replacement in libpijul/src/fs.rs at line 624 [22.737429]
B:BD[22.754390] → [22.754390:754401]
```
        ),
```
[22.754390]
[22.754401]
```
        )
        .map_err(|e| e.0)?,
```
Replacement in libpijul/src/fs.rs at line 629 [22.737429]
B:BD[22.754448] → [22.754448:754454]
```
    }
```
[22.754448]
[22.754454]
```
    })
```

Replacement in libpijul/src/fs.rs at line 635 [22.737429]

B:BD[22.754635] → [22.754635:754725]

pub struct GraphBasenames<'txn, 'channel, 'changes, T: TxnT, P: ChangeStore + 'changes> {

[22.754635]

[22.754725]

pub struct GraphBasenames<'txn, 'channel, 'changes, T: GraphTxnT, P: ChangeStore + 'changes> {

Replacement in libpijul/src/fs.rs at line 637 [22.737429]
B:BD[22.754743] → [22.754743:754778]
```
    channel: &'channel Channel<T>,
```
[22.754743]
[22.754778]
```
    channel: &'channel T::Graph,
```

Replacement in libpijul/src/fs.rs at line 643 [22.737429]

B:BD[22.754861] → [22.754861:754937]

impl<'txn, 'channel, 'changes, T: TxnT, P: ChangeStore + 'changes> Iterator

[22.754861]

[22.754937]

impl<'txn, 'channel, 'changes, T: GraphTxnT, P: ChangeStore + 'changes> Iterator

Replacement in libpijul/src/fs.rs at line 646 [22.737429]

B:BD[22.754994] → [22.754994:755055]

    type Item = (Position<ChangeId>, InodeMetadata, String);

[22.754994]

[22.755055]

    type Item = Result<(Position<ChangeId>, InodeMetadata, String), T::GraphError>;

Replacement in libpijul/src/fs.rs at line 648 [22.737429]

B:BD[22.755102] → [61.0:51]

        while let Some(parent) = self.adj.next() {

[22.755102]

[26.63128]

        loop {
            let parent = match self.adj.next() {
                Some(Ok(n)) => n,
                Some(Err(e)) => return Some(Err(e.0)),
                None => return None,
            };

Replacement in libpijul/src/fs.rs at line 657 [22.737429]

B:BD[22.755328] → [22.755328:755404]

                .get_contents(|p| self.txn.get_external(p), dest, &mut buf)

[22.755328]

[22.755404]

                .get_contents(|p| self.txn.get_external(p).unwrap(), dest, &mut buf)

Replacement in libpijul/src/fs.rs at line 663 [22.737429]

B:BD[22.755657] → [61.52:106]

            if let Some(grandparent) = iter_adjacent(

[22.755657]

[26.63260]

            match iter_adjacent(

Replacement in libpijul/src/fs.rs at line 669 [22.737429]

B:BD[26.63488] → [26.63488:63522]

B:BD[26.63522] → [61.107:187]

            )
            .next()
            {
                return Some((grandparent.dest, perms, basename));

[26.63488]

[61.187]

            ) {
                Ok(mut adj) => match adj.next() {
                    Some(Ok(grandparent)) => return Some(Ok((grandparent.dest, perms, basename))),
                    Some(Err(e)) => return Some(Err(e.0)),
                    None => {}
                },
                Err(e) => return Some(Err(e.0)),

Deletion in libpijul/src/fs.rs at line 678 [22.737429]
B:BD[61.211] → [61.211:224]
```
        None
```
Replacement in libpijul/src/fs.rs at line 688 [22.737429]
B:BD[22.756353] → [22.756353:756388]
```
    channel: &'channel Channel<T>,
```
[22.756353]
[22.756388]
```
    channel: &'channel T::Graph,
```

Replacement in libpijul/src/fs.rs at line 690 [22.737429]

B:BD[22.756417] → [22.756417:756469]

) -> GraphBasenames<'txn, 'channel, 'changes, T, P>

[22.756417]

[22.756469]

) -> Result<GraphBasenames<'txn, 'channel, 'changes, T, P>, T::GraphError>

Replacement in libpijul/src/fs.rs at line 692 [22.737429]
B:BD[22.756475] → [22.756475:756488]
```
    T: TxnT,
```
[22.756475]
[22.756488]
```
    T: GraphTxnT,
```
Replacement in libpijul/src/fs.rs at line 695 [22.737429]
B:BD[22.756510] → [22.756510:756531]
```
    GraphBasenames {
```
[22.756510]
[22.756531]
```
    Ok(GraphBasenames {
```
Replacement in libpijul/src/fs.rs at line 699 [22.737429]
∅:D[26.63591] → [22.756588:756610]
B:BD[22.756588] → [22.756588:756610]
```
            &channel,
```
[26.63591]
[22.756610]
```
            channel,
```
Replacement in libpijul/src/fs.rs at line 703 [22.737429]
B:BD[22.756764] → [22.756764:756775]
```
        ),
```
[22.756764]
[22.756775]
```
        )
        .map_err(|e| e.0)?,
```
Replacement in libpijul/src/fs.rs at line 708 [22.737429]
B:BD[22.756822] → [22.756822:756828]
```
    }
```
[22.756822]
[22.756828]
```
    })
```

Replacement in libpijul/src/fs.rs at line 720 [22.737429]

B:BD[22.757313] → [22.757313:757405]

pub fn iter_paths<T: TxnT, F: FnMut(&mut dyn Iterator<Item = Position<ChangeId>>) -> bool>(

[22.757313]

[22.757405]

pub fn iter_paths<T: GraphTxnT, F: FnMut(&mut dyn Iterator<Item = Position<ChangeId>>) -> bool>(

Replacement in libpijul/src/fs.rs at line 722 [22.737429]
B:BD[22.757418] → [22.757418:757447]
```
    channel: &ChannelRef<T>,
```
[22.757418]
[22.757447]
```
    graph: &T::Graph,
```
Replacement in libpijul/src/fs.rs at line 725 [22.737429]
B:BD[22.757490] → [22.757490:757532]
```
) {
    let channel = channel.r.borrow();
```
[22.757490]
[22.757532]
```
) -> Result<(), T::GraphError> {
```

Replacement in libpijul/src/fs.rs at line 743 [22.737429]

B:BD[22.758177] → [26.63592:63688]

∅:D[26.63688] → [22.758289:758464]

B:BD[22.758289] → [22.758289:758464]

B:BD[22.758464] → [26.63689:63870]

∅:D[26.63870] → [22.758664:758898]

B:BD[22.758664] → [22.758664:758898]

            for (_, parent) in iter_graph(txn, &channel.graph, cur_key.inode_vertex(), Some(e))
                .take_while(|&(k, _)| k == cur_key.inode_vertex())
                .filter(|&(_, ref v)| v.flag.contains(EdgeFlags::FOLDER | EdgeFlags::PARENT))
            {
                let parent_dest = find_block_end(txn, &channel, parent.dest).unwrap();
                for (_, grandparent) in iter_graph(txn, &channel.graph, parent_dest, Some(e))
                    .take_while(|&(k, _)| k == parent_dest)
                    .filter(|&(_, ref v)| v.flag.contains(EdgeFlags::FOLDER | EdgeFlags::PARENT))
                {
                    stack.push((grandparent.dest, false))

[22.758177]

[22.758898]

            for x in iter_graph(txn, &graph, cur_key.inode_vertex(), Some(e)).map_err(|e| e.0)? {
                let (k, parent) = x.map_err(|e| e.0)?;
                if k != cur_key.inode_vertex() {
                    break;
                } else if !parent.flag.contains(EdgeFlags::FOLDER | EdgeFlags::PARENT) {
                    continue;
                }
                let parent_dest = find_block_end(txn, &graph, parent.dest).unwrap();
                for x in iter_graph(txn, &graph, parent_dest, Some(e)).map_err(|e| e.0)? {
                    let (k, grandparent) = x.map_err(|e| e.0)?;
                    if k != parent_dest {
                        break;
                    }
                    if grandparent
                        .flag
                        .contains(EdgeFlags::FOLDER | EdgeFlags::PARENT)
                    {
                        stack.push((grandparent.dest, false))
                    }

Insertion in libpijul/src/fs.rs at line 769 [22.737429]
[22.759025]
[22.759025]
```
    Ok(())
```

Replacement in libpijul/src/fs.rs at line 772 [22.737429]

B:BD[22.759028] → [22.759028:759087]

pub(crate) fn follow_oldest_path<T: TxnT, C: ChangeStore>(

[22.759028]

[22.759087]

pub(crate) fn follow_oldest_path<T: ChannelTxnT, C: ChangeStore>(

Replacement in libpijul/src/fs.rs at line 775 [22.737429]
B:BD[22.759117] → [22.759117:759146]
```
    channel: &ChannelRef<T>,
```
[22.759117]
[22.759146]
```
    channel: &Channel<T>,
```

Replacement in libpijul/src/fs.rs at line 777 [22.737429]

B:BD[22.759162] → [23.32049:32110]

) -> Result<(Position<ChangeId>, bool), FsError<C::Error>> {

[22.759162]

[22.759219]

) -> Result<(Position<ChangeId>, bool), FsErrorC<C::Error, T::GraphError>> {

Deletion in libpijul/src/fs.rs at line 779 [22.737429]
B:BD[22.759247] → [22.759247:759283]
```
    let channel = channel.borrow();
```

Replacement in libpijul/src/fs.rs at line 787 [22.737429]

B:BD[22.759605] → [26.63871:64035]

        for name in iter_adjacent(txn, &channel, current.inode_vertex(), flag0, flag1) {
            let name_dest = find_block(txn, &channel, name.dest).unwrap();

[22.759605]

[22.759767]

        for name in iter_adjacent(txn, &channel.graph, current.inode_vertex(), flag0, flag1)? {
            let name = name?;
            let name_dest = find_block(txn, &channel.graph, name.dest).unwrap();

Replacement in libpijul/src/fs.rs at line 793 [22.737429]

B:BD[23.32131] → [23.32131:32253]

                .get_contents(|h| txn.get_external(h), name_dest, &mut name_buf)
                .map_err(FsError::Txn)?;

[23.32131]

[22.759934]

                .get_contents(|h| txn.get_external(h).unwrap(), name_dest, &mut name_buf)
                .map_err(FsErrorC::Changestore)?;

Replacement in libpijul/src/fs.rs at line 812 [22.737429]

B:BD[22.760549] → [26.64036:64107]

            current = iter_adjacent(txn, &channel, next, flag0, flag1)

[22.760549]

[22.760636]

            current = iter_adjacent(txn, &channel.graph, next, flag0, flag1)?

Replacement in libpijul/src/fs.rs at line 814 [22.737429]
B:BD[22.760660] → [22.760660:760686]
```
                .unwrap()
```
[22.760660]
[22.760686]
```
                .unwrap()?
```

Replacement in libpijul/src/fs.rs at line 817 [22.737429]

B:BD[22.760725] → [23.32254:32315]

            return Err(FsError::NotFound(path.to_string()));

[22.760725]

[22.760849]

            return Err(FsErrorC::NotFound(FsNotFound(path.to_string())));

Replacement in libpijul/src/fs.rs at line 823 [22.737429]
B:BD[22.760952] → [22.760952:760995]
```
pub fn find_path<T: TxnT, C: ChangeStore>(
```
[22.760897]
[22.760995]
```
pub fn find_path<T: ChannelTxnT, C: ChangeStore>(
```

Replacement in libpijul/src/fs.rs at line 829 [22.737429]

B:BD[22.761102] → [23.32316:32356]

) -> Result<(String, bool), C::Error> {

[22.761102]

[22.761147]

) -> Result<(String, bool), crate::output::FileError<C::Error, T::GraphError>> {

Replacement in libpijul/src/fs.rs at line 839 [22.737429]

B:BD[22.761463] → [26.64108:64178]

        let inode_vertex = find_block_end(txn, &channel, v).unwrap();

[22.761463]

[22.761532]

        let inode_vertex = find_block_end(txn, &channel.graph, v).unwrap();

Replacement in libpijul/src/fs.rs at line 841 [22.737429]

B:BD[22.761584] → [26.64179:64261]

        for name in iter_adjacent(txn, channel, v.inode_vertex(), flag0, flag1) {

[22.761584]

[22.761665]

        for name in iter_adjacent(txn, &channel.graph, v.inode_vertex(), flag0, flag1)? {
            let name = name?;

Replacement in libpijul/src/fs.rs at line 848 [22.737429]

B:BD[22.761841] → [22.761841:761914]

                .get_changeset(&channel.changes, name.dest.change, None)

[22.761841]

[22.761914]

                .get_changeset(&channel.changes, name.dest.change, None)?

Replacement in libpijul/src/fs.rs at line 851 [22.737429]

B:BD[22.761942] → [26.64262:64341]

            let name_dest = find_block_end(txn, &channel, name.dest).unwrap();

[22.761942]

[22.762020]

            let name_dest = find_block_end(txn, &channel.graph, name.dest).unwrap();

Replacement in libpijul/src/fs.rs at line 853 [22.737429]

B:BD[22.762071] → [26.64342:64427]

B:BD[26.64427] → [62.641:723]

∅:D[62.723] → [22.762280:762294]

B:BD[22.762280] → [22.762280:762294]

            if let Some(next) = iter_adjacent(txn, channel, name_dest, flag0, flag1)
                .find(|e| e.flag.contains(EdgeFlags::PARENT | EdgeFlags::FOLDER))
            {

[22.762071]

[22.762294]

            let mut next = None;
            for e in iter_adjacent(txn, &channel.graph, name_dest, flag0, flag1)? {
                let e = e?;
                if e.flag.contains(EdgeFlags::PARENT | EdgeFlags::FOLDER) {
                    next = Some(e);
                    break;
                }
            }
            if let Some(next) = next {

Replacement in libpijul/src/fs.rs at line 882 [22.737429]

B:BD[22.762998] → [22.762998:763079]

            changes.get_contents(|h| txn.get_external(h), name, &mut name_buf)?;

[22.762998]

[22.763079]

            changes
                .get_contents(|h| txn.get_external(h).unwrap(), name, &mut name_buf)
                .map_err(crate::output::FileError::Changestore)?;

Replacement in libpijul/src/find_alive.rs at line 4 [22.763306]
∅:D[23.32358] → [22.763521:763561]
B:BD[22.763521] → [22.763521:763561]
```
pub(crate) fn find_alive_down<T: TxnT>(
```
[23.32358]
[22.763561]
```
pub(crate) fn find_alive_down<T: GraphTxnT>(
```
Replacement in libpijul/src/find_alive.rs at line 6 [22.763306]
B:BD[22.763574] → [22.763574:763600]
```
    channel: &Channel<T>,
```
[22.763574]
[22.763600]
```
    channel: &T::Graph,
```
Replacement in libpijul/src/find_alive.rs at line 8 [22.763306]
B:BD[22.763631] → [23.32359:32412]
```
) -> Result<HashSet<Vertex<ChangeId>>, BlockError> {
```
[22.763631]
[22.763686]
```
) -> Result<HashSet<Vertex<ChangeId>>, BlockError<T::GraphError>> {
```

Replacement in libpijul/src/find_alive.rs at line 23 [22.763306]

B:BD[22.764231] → [21.15531:15586]

        for v in iter_adj_all(txn, &channel, vertex) {

[22.764231]

[22.764387]

        for v in iter_adj_all(txn, &channel, vertex)? {
            let v = v?;

Replacement in libpijul/src/find_alive.rs at line 48 [22.763306]
∅:D[23.32414] → [22.765190:765228]
B:BD[22.765190] → [22.765190:765228]
```
pub(crate) fn find_alive_up<T: TxnT>(
```
[23.32414]
[22.765228]
```
pub(crate) fn find_alive_up<T: GraphTxnT>(
```
Replacement in libpijul/src/find_alive.rs at line 50 [22.763306]
B:BD[22.765241] → [22.765241:765267]
```
    channel: &Channel<T>,
```
[22.765241]
[21.15587]
```
    channel: &T::Graph,
```

Replacement in libpijul/src/find_alive.rs at line 54 [22.763306]

B:BD[21.15653] → [21.15653:15706]

) -> Result<HashSet<Vertex<ChangeId>>, BlockError> {

[21.15653]

[22.765386]

) -> Result<HashSet<Vertex<ChangeId>>, BlockError<T::GraphError>> {

Replacement in libpijul/src/find_alive.rs at line 73 [22.763306]

B:BD[21.15740] → [21.15740:15798]

        let mut it = iter_adj_all(txn, &channel, vertex);

[21.15740]

[21.15798]

        let mut it = iter_adj_all(txn, &channel, vertex)?;

Insertion in libpijul/src/find_alive.rs at line 75 [22.763306]
[21.15838]
[22.766233]
```
            let v = v?;
```

Replacement in libpijul/src/find_alive.rs at line 86 [22.763306]

B:BD[21.16111] → [21.16111:16202]

                    is_file |= it.any(|e| !e.flag.intersects(EdgeFlags::parent_folder()));

[21.16111]

[21.16202]

                    for e in it {
                        let e = e?;
                        is_file |= !e.flag.intersects(EdgeFlags::parent_folder())
                    }

Replacement in libpijul/src/diff/mod.rs at line 34 [22.793247]

B:BD[23.33244] → [23.33244:33297]

pub enum DiffError<P: std::error::Error + 'static> {

[23.33244]

[23.33297]

pub enum DiffError<P: std::error::Error + 'static, T: std::error::Error + 'static> {
    #[error(transparent)]
    Output(#[from] crate::output::FileError<P, T>),

Replacement in libpijul/src/diff/mod.rs at line 38 [22.793247]

B:BD[23.33323] → [23.33323:33372]

    Output(#[from] crate::output::FileError<P>),

[23.33323]

[23.33372]

    Txn(T),
}
impl<T: std::error::Error + 'static, C: std::error::Error + 'static> std::convert::From<TxnErr<T>>
    for DiffError<C, T>
{
    fn from(e: TxnErr<T>) -> Self {
        DiffError::Txn(e.0)
    }

Replacement in libpijul/src/diff/mod.rs at line 50 [22.793247]
B:BD[22.794116] → [22.794116:794165]
```
    pub(crate) fn diff<T: TxnT, P: ChangeStore>(
```
[22.794116]
[22.794165]
```
    pub(crate) fn diff<T: ChannelTxnT, P: ChangeStore>(
```
Replacement in libpijul/src/diff/mod.rs at line 60 [22.793247]
B:BD[22.794388] → [23.33375:33418]
```
    ) -> Result<(), DiffError<P::Error>> {
```
[22.794388]
[22.794425]
```
    ) -> Result<(), DiffError<P::Error, T::GraphError>> {
```

Replacement in libpijul/src/diff/mod.rs at line 67 [22.793247]

B:BD[39.5921] → [39.5921:5994]

            self.diff_binary(changes, txn, channel, path, inode, a, &b);

[39.5921]

[39.5994]

            self.diff_binary(changes, txn, &channel.graph, path, inode, a, &b)?;

Replacement in libpijul/src/diff/mod.rs at line 122 [22.793247]
B:BD[22.796903] → [22.796903:796932]
```
                    channel,
```
[22.796903]
[22.796932]
```
                    &channel.graph,
```
Replacement in libpijul/src/diff/mod.rs at line 129 [22.793247]
B:BD[22.797108] → [54.293:312]
```
                );
```
[22.797108]
[22.797127]
```
                )?;
```
Replacement in libpijul/src/diff/mod.rs at line 139 [22.793247]
B:BD[22.797338] → [22.797338:797383]
```
    fn diff_binary<T: TxnT, C: ChangeStore>(
```
[22.797338]
[22.797383]
```
    fn diff_binary<T: GraphTxnT, C: ChangeStore>(
```
Replacement in libpijul/src/diff/mod.rs at line 143 [22.793247]
B:BD[22.797440] → [22.797440:797470]
```
        channel: &Channel<T>,
```
[22.797440]
[22.797470]
```
        channel: &T::Graph,
```
Replacement in libpijul/src/diff/mod.rs at line 148 [22.793247]
B:BD[22.797588] → [22.797588:797596]
```
    ) {
```
[22.797588]
[22.797596]
```
    ) -> Result<(), TxnErr<T::GraphError>> {
```

Replacement in libpijul/src/diff/mod.rs at line 162 [22.793247]

B:BD[22.798199] → [26.65554:65652]

            for e in iter_adjacent(txn, channel, v.vertex, EdgeFlags::PARENT, EdgeFlags::all()) {

[22.798199]

[22.798296]

            for e in iter_adjacent(txn, channel, v.vertex, EdgeFlags::PARENT, EdgeFlags::all())? {
                let e = e?;

Replacement in libpijul/src/diff/mod.rs at line 220 [22.793247]
B:BD[22.800730] → [22.800730:800741]
```
        })
```
[22.800730]
[22.800741]
```
        });
        Ok(())
```
Replacement in libpijul/src/diff/delete.rs at line 11 [22.805350]
B:BD[22.805718] → [22.805718:805753]
```
    pub(super) fn delete<T: TxnT>(
```
[22.805718]
[22.805753]
```
    pub(super) fn delete<T: GraphTxnT>(
```
Replacement in libpijul/src/diff/delete.rs at line 14 [22.805350]
B:BD[22.805789] → [22.805789:805819]
```
        channel: &Channel<T>,
```
[22.805789]
[22.805819]
```
        channel: &T::Graph,
```
Replacement in libpijul/src/diff/delete.rs at line 21 [22.805350]
B:BD[22.805988] → [54.400:408]
```
    ) {
```
[22.805988]
[22.806025]
```
    ) -> Result<(), TxnErr<T::GraphError>> {
```

Replacement in libpijul/src/diff/delete.rs at line 23 [22.805350]

B:BD[22.806059] → [22.806059:806121]

        self.delete_lines(txn, channel, diff, d, lines_a, r);

[22.806059]

[22.806121]

        self.delete_lines(txn, channel, diff, d, lines_a, r)?;

Insertion in libpijul/src/diff/delete.rs at line 37 [22.805350]
[22.806419]
[22.806434]
```
        Ok(())
```
Replacement in libpijul/src/diff/delete.rs at line 47 [22.805350]
B:BD[22.806715] → [22.806715:806745]
```
    fn delete_lines<T: TxnT>(
```
[22.806715]
[22.806745]
```
    fn delete_lines<T: GraphTxnT>(
```
Replacement in libpijul/src/diff/delete.rs at line 50 [22.805350]
B:BD[22.806781] → [22.806781:806811]
```
        channel: &Channel<T>,
```
[22.806781]
[22.806811]
```
        channel: &T::Graph,
```

Replacement in libpijul/src/diff/delete.rs at line 55 [22.805350]

B:BD[22.806904] → [22.806904:806984]

    ) {
        let deletion = delete_lines(txn, channel, diff, d, lines_a, r);

[22.806904]

[22.806984]

    ) -> Result<(), TxnErr<T::GraphError>> {
        let deletion = delete_lines(txn, channel, diff, d, lines_a, r)?;

Insertion in libpijul/src/diff/delete.rs at line 81 [22.805350]
[22.808311]
[22.808311]
```
        Ok(())
```
Replacement in libpijul/src/diff/delete.rs at line 85 [22.805350]
∅:D[63.3] → [22.808374:808400]
B:BD[22.808374] → [22.808374:808400]
```
fn delete_lines<T: TxnT>(
```
[63.3]
[22.808400]
```
fn delete_lines<T: GraphTxnT>(
```
Replacement in libpijul/src/diff/delete.rs at line 87 [22.805350]
B:BD[22.808413] → [22.808413:808439]
```
    channel: &Channel<T>,
```
[22.808413]
[22.808439]
```
    channel: &T::Graph,
```
Replacement in libpijul/src/diff/delete.rs at line 92 [22.805350]
B:BD[22.808516] → [22.808516:808532]
```
) -> Deletion {
```
[22.808516]
[22.808532]
```
) -> Result<Deletion, TxnErr<T::GraphError>> {
```
Replacement in libpijul/src/diff/delete.rs at line 116 [22.805350]
B:BD[22.809674] → [42.1294:1308]
```
            )
```
[22.809674]
[42.1308]
```
            )?
```
Replacement in libpijul/src/diff/delete.rs at line 148 [22.805350]
B:BD[22.810144] → [22.810144:810154]
```
        )
```
[22.810144]
[22.810154]
```
        )?
```
Replacement in libpijul/src/diff/delete.rs at line 150 [22.805350]
B:BD[22.810160] → [22.810160:810173]
```
    deletion
```
[22.810160]
[22.810173]
```
    Ok(deletion)
```
Replacement in libpijul/src/diff/delete.rs at line 153 [22.805350]
B:BD[22.810231] → [22.810231:810259]
```
fn delete_parents<T: TxnT>(
```
[22.810176]
[22.810259]
```
fn delete_parents<T: GraphTxnT>(
```
Replacement in libpijul/src/diff/delete.rs at line 155 [22.805350]
B:BD[22.810272] → [22.810272:810298]
```
    channel: &Channel<T>,
```
[22.810272]
[22.810298]
```
    channel: &T::Graph,
```
Replacement in libpijul/src/diff/delete.rs at line 159 [22.805350]
B:BD[22.810391] → [22.810391:810395]
B:BD[22.810395] → [26.65735:65763]
```
) {
    for v in iter_adjacent(
```
[22.810391]
[26.65763]
```
) -> Result<(), TxnErr<T::GraphError>> {
    for e in iter_adjacent(
```

Replacement in libpijul/src/diff/delete.rs at line 166 [22.805350]

B:BD[26.65866] → [26.65866:65963]

∅:D[26.65963] → [22.810627:810684]

B:BD[22.810627] → [22.810627:810684]

    )
    .filter(|e| e.flag.contains(EdgeFlags::PARENT) && !e.flag.contains(EdgeFlags::PSEUDO))
    {
        let previous = v.flag - EdgeFlags::PARENT;

[26.65866]

[42.1831]

    )? {
        let e = e?;
        if !e.flag.contains(EdgeFlags::PARENT) || e.flag.contains(EdgeFlags::PSEUDO) {
            continue;
        }
        let previous = e.flag - EdgeFlags::PARENT;

Replacement in libpijul/src/diff/delete.rs at line 174 [22.805350]

B:BD[42.1912] → [42.1912:1962]

            && !v.flag.contains(EdgeFlags::BLOCK)

[42.1912]

[42.1962]

            && !e.flag.contains(EdgeFlags::BLOCK)

Replacement in libpijul/src/diff/delete.rs at line 182 [22.805350]
B:BD[22.811053] → [22.811053:811088]
```
                v.dest.to_option()
```
[22.811053]
[22.811088]
```
                e.dest.to_option()
```

Replacement in libpijul/src/diff/delete.rs at line 187 [22.805350]

B:BD[22.811281] → [22.811281:811331]

            introduced_by: Some(v.introduced_by),

[22.811281]

[64.47]

            introduced_by: Some(e.introduced_by),

Insertion in libpijul/src/diff/delete.rs at line 190 [22.805350]
[22.811869]
[22.811869]
```
    Ok(())
```
Replacement in libpijul/src/diff/delete.rs at line 265 [22.805350]
∅:D[63.7] → [22.814473:814504]
B:BD[22.814473] → [22.814473:814504]
```
fn resurrect_zombies<T: TxnT>(
```
[63.7]
[22.814504]
```
fn resurrect_zombies<T: GraphTxnT>(
```
Replacement in libpijul/src/diff/delete.rs at line 267 [22.805350]
B:BD[22.814517] → [22.814517:814543]
```
    channel: &Channel<T>,
```
[22.814517]
[22.814543]
```
    channel: &T::Graph,
```
Replacement in libpijul/src/diff/delete.rs at line 276 [22.805350]
B:BD[22.814723] → [22.814723:814727]
```
) {
```
[22.814723]
[42.1973]
```
) -> Result<(), TxnErr<T::GraphError>> {
```
Replacement in libpijul/src/diff/delete.rs at line 312 [22.805350]
B:BD[22.815923] → [22.815923:815938]
```
            );
```
[22.815923]
[22.815938]
```
            )?;
```
Insertion in libpijul/src/diff/delete.rs at line 321 [22.805350]
[22.816200]
[22.816200]
```
    Ok(())
```
Replacement in libpijul/src/diff/delete.rs at line 324 [22.805350]
∅:D[63.9] → [22.816267:816297]
B:BD[22.816267] → [22.816267:816297]
```
fn resurrect_zombie<T: TxnT>(
```
[63.9]
[22.816297]
```
fn resurrect_zombie<T: GraphTxnT>(
```
Replacement in libpijul/src/diff/delete.rs at line 326 [22.805350]
B:BD[22.816310] → [22.816310:816336]
```
    channel: &Channel<T>,
```
[22.816310]
[22.816336]
```
    channel: &T::Graph,
```
Replacement in libpijul/src/diff/delete.rs at line 330 [22.805350]
B:BD[22.816420] → [22.816420:816424]
```
) {
```
[22.816420]
[42.2085]
```
) -> Result<(), TxnErr<T::GraphError>> {
```
Replacement in libpijul/src/diff/delete.rs at line 338 [22.805350]
B:BD[22.816579] → [22.816579:816587]
```
    ) {
```
[22.816579]
[22.816587]
```
    )? {
        let e = e?;
```
Insertion in libpijul/src/diff/delete.rs at line 357 [22.805350]
[22.817189]
[22.817189]
```
    Ok(())
```

Replacement in libpijul/src/change.rs at line 195 [22.831311]

B:BD[22.835829] → [22.835829:835927]

pub fn dependencies<'a, Local: 'a, I: Iterator<Item = &'a Record<Option<Hash>, Local>>, T: TxnT>(

[22.835774]

[22.835927]

pub fn dependencies<
    'a,
    Local: 'a,
    I: Iterator<Item = &'a Record<Option<Hash>, Local>>,
    T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
>(

Replacement in libpijul/src/change.rs at line 202 [22.831311]
B:BD[22.835940] → [22.835940:835969]
```
    channel: &ChannelRef<T>,
```
[22.835940]
[22.835969]
```
    channel: &Channel<T>,
```
Replacement in libpijul/src/change.rs at line 204 [22.831311]
B:BD[22.835985] → [65.316:346]
```
) -> (Vec<Hash>, Vec<Hash>) {
```
[22.835985]
[22.836025]
```
) -> Result<(Vec<Hash>, Vec<Hash>), TxnErr<T::DepsError>> {
```
Deletion in libpijul/src/change.rs at line 207 [22.831311]
B:BD[22.836104] → [22.836104:836142]
```
    let channel = channel.r.borrow();
```

Replacement in libpijul/src/change.rs at line 236 [22.831311]

B:BD[22.837398] → [22.837398:837559]

                    add_zombie_deps_from(txn, &channel, &mut zombie_deps, e.from);
                    add_zombie_deps_to(txn, &channel, &mut zombie_deps, e.to)

[22.837398]

[22.837559]

                    add_zombie_deps_from(txn, &channel.graph, &mut zombie_deps, e.from)?;
                    add_zombie_deps_to(txn, &channel.graph, &mut zombie_deps, e.to)?

Replacement in libpijul/src/change.rs at line 242 [22.831311]
B:BD[22.837662] → [22.837662:837714]
```
    let deps = minimize_deps(txn, &channel, &deps);
```
[22.837662]
[22.837714]
```
    let deps = minimize_deps(txn, &channel, &deps)?;
```

Replacement in libpijul/src/change.rs at line 248 [22.831311]

B:BD[65.446] → [65.446:540]

        let a = txn.get_internal(*a).unwrap();
        let b = txn.get_internal(*b).unwrap();

[65.446]

[26.66061]

        let a = txn.get_internal(*a).unwrap().unwrap();
        let b = txn.get_internal(*b).unwrap().unwrap();

Replacement in libpijul/src/change.rs at line 251 [22.831311]

B:BD[26.66114] → [26.66114:66178]

            .cmp(&txn.get_changeset(&channel.changes, b, None))

[26.66114]

[65.644]

            .unwrap()
            .cmp(&txn.get_changeset(&channel.changes, b, None).unwrap())

Replacement in libpijul/src/change.rs at line 256 [22.831311]

B:BD[65.757] → [65.757:851]

        let a = txn.get_internal(*a).unwrap();
        let b = txn.get_internal(*b).unwrap();

[65.757]

[26.66179]

        let a = txn.get_internal(*a).unwrap().unwrap();
        let b = txn.get_internal(*b).unwrap().unwrap();

Replacement in libpijul/src/change.rs at line 259 [22.831311]

B:BD[26.66232] → [26.66232:66296]

            .cmp(&txn.get_changeset(&channel.changes, b, None))

[26.66232]

[65.955]

            .unwrap()
            .cmp(&txn.get_changeset(&channel.changes, b, None).unwrap())

Replacement in libpijul/src/change.rs at line 262 [22.831311]
∅:D[65.963] → [22.837778:837802]
B:BD[22.837778] → [22.837778:837802]
```
    (deps, zombie_deps)
```
[65.963]
[22.837802]
```
    Ok((deps, zombie_deps))
```

Replacement in libpijul/src/change.rs at line 265 [22.831311]

B:BD[22.837805] → [26.66297:66393]

pub fn full_dependencies<T: TxnT>(txn: &T, channel: &ChannelRef<T>) -> (Vec<Hash>, Vec<Hash>) {

[22.837805]

[22.837922]

pub fn full_dependencies<T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>>(
    txn: &T,
    channel: &ChannelRef<T>,
) -> Result<(Vec<Hash>, Vec<Hash>), TxnErr<T::DepsError>> {

Replacement in libpijul/src/change.rs at line 271 [22.831311]

B:BD[22.837994] → [26.66394:66451]

∅:D[26.66451] → [22.838050:838097]

B:BD[22.838050] → [22.838050:838097]

    for (_, (ch, _)) in changeid_log(txn, &channel, 0) {
        let h = txn.get_external(ch).unwrap();

[22.837994]

[22.838097]

    for x in changeid_log(txn, &channel, 0)? {
        let (_, (ch, _)) = x?;
        let h = txn.get_external(ch)?.unwrap();

Replacement in libpijul/src/change.rs at line 276 [22.831311]

B:BD[22.838127] → [22.838127:838179]

B:BD[22.838179] → [65.995:1018]

    let deps = minimize_deps(txn, &channel, &deps);
    (deps, Vec::new())

[22.838127]

[22.838207]

    let deps = minimize_deps(txn, &channel, &deps)?;
    Ok((deps, Vec::new()))

Replacement in libpijul/src/change.rs at line 280 [22.831311]
B:BD[22.838265] → [22.838265:838299]
```
fn add_zombie_deps_from<T: TxnT>(
```
[22.838210]
[22.838299]
```
fn add_zombie_deps_from<T: GraphTxnT>(
```
Replacement in libpijul/src/change.rs at line 282 [22.831311]
B:BD[22.838312] → [22.838312:838338]
```
    channel: &Channel<T>,
```
[22.838312]
[22.838338]
```
    channel: &T::Graph,
```
Replacement in libpijul/src/change.rs at line 285 [22.831311]
B:BD[22.838412] → [22.838412:838416]
```
) {
```
[22.838412]
[22.838416]
```
) -> Result<(), TxnErr<T::GraphError>> {
```

Replacement in libpijul/src/change.rs at line 288 [22.831311]

B:BD[22.838485] → [22.838485:838535]

            change: txn.get_internal(p).unwrap(),

[22.838485]

[22.838535]

            change: txn.get_internal(p)?.unwrap(),

Replacement in libpijul/src/change.rs at line 292 [22.831311]
B:BD[22.838587] → [22.838587:838603]
```
        return;
```
[22.838587]
[22.838603]
```
        return Ok(());
```

Replacement in libpijul/src/change.rs at line 295 [22.831311]

B:BD[26.66514] → [21.17040:17091]

∅:D[26.66604] → [22.838760:838826]

∅:D[21.17091] → [22.838760:838826]

B:BD[22.838760] → [22.838760:838826]

    for edge in iter_adj_all(txn, channel, from) {
        if let Some(ext) = txn.get_external(edge.introduced_by) {

[26.66514]

[22.838826]

    for edge in iter_adj_all(txn, channel, from)? {
        let edge = edge?;
        if let Some(ext) = txn.get_external(edge.introduced_by)? {

Replacement in libpijul/src/change.rs at line 303 [22.831311]

B:BD[22.838961] → [22.838961:839025]

        if let Some(ext) = txn.get_external(edge.dest.change) {

[22.838961]

[22.839025]

        if let Some(ext) = txn.get_external(edge.dest.change)? {

Insertion in libpijul/src/change.rs at line 310 [22.831311]
[22.839166]
[22.839166]
```
    Ok(())
```
Replacement in libpijul/src/change.rs at line 313 [22.831311]
B:BD[22.839169] → [22.839169:839201]
```
fn add_zombie_deps_to<T: TxnT>(
```
[22.839169]
[22.839201]
```
fn add_zombie_deps_to<T: GraphTxnT>(
```
Replacement in libpijul/src/change.rs at line 315 [22.831311]
B:BD[22.839214] → [22.839214:839240]
```
    channel: &Channel<T>,
```
[22.839214]
[22.839240]
```
    channel: &T::Graph,
```
Replacement in libpijul/src/change.rs at line 318 [22.831311]
B:BD[22.839310] → [22.839310:839314]
```
) {
```
[22.839310]
[22.839314]
```
) -> Result<(), TxnErr<T::GraphError>> {
```

Replacement in libpijul/src/change.rs at line 321 [22.831311]

B:BD[22.839381] → [22.839381:839431]

            change: txn.get_internal(p).unwrap(),

[22.839381]

[22.839431]

            change: txn.get_internal(p)?.unwrap(),

Replacement in libpijul/src/change.rs at line 325 [22.831311]
B:BD[22.839483] → [22.839483:839499]
```
        return;
```
[22.839483]
[22.839499]
```
        return Ok(());
```

Replacement in libpijul/src/change.rs at line 329 [22.831311]

B:BD[22.839576] → [21.17092:17145]

∅:D[26.66758] → [22.839667:839737]

∅:D[21.17145] → [22.839667:839737]

B:BD[22.839667] → [22.839667:839737]

        for edge in iter_adj_all(txn, channel, to) {
            if let Some(ext) = txn.get_external(edge.introduced_by) {

[22.839576]

[22.839737]

        for edge in iter_adj_all(txn, channel, to)? {
            let edge = edge?;
            if let Some(ext) = txn.get_external(edge.introduced_by)? {

Replacement in libpijul/src/change.rs at line 337 [22.831311]

B:BD[22.839892] → [22.839892:839960]

            if let Some(ext) = txn.get_external(edge.dest.change) {

[22.839892]

[22.839960]

            if let Some(ext) = txn.get_external(edge.dest.change)? {

Insertion in libpijul/src/change.rs at line 349 [22.831311]
[22.840253]
[22.840253]
```
    Ok(())
```

Replacement in libpijul/src/change.rs at line 351 [22.831311]

B:BD[22.840310] → [65.1019:1114]

fn minimize_deps<T: TxnT>(txn: &T, channel: &Channel<T>, deps: &BTreeSet<Hash>) -> Vec<Hash> {

[22.840255]

[22.840410]


fn minimize_deps<T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>>(
    txn: &T,
    channel: &Channel<T>,
    deps: &BTreeSet<Hash>,
) -> Result<Vec<Hash>, TxnErr<T::DepsError>> {

Replacement in libpijul/src/change.rs at line 365 [22.831311]
B:BD[22.840655] → [22.840655:840703]
```
        let id = txn.get_internal(*h).unwrap();
```
[22.840655]
[22.840703]
```
        let id = txn.get_internal(*h)?.unwrap();
```

Replacement in libpijul/src/change.rs at line 367 [22.831311]

B:BD[22.840736] → [22.840736:840811]

        let time = txn.get_changeset(&channel.changes, id, None).unwrap();

[22.840736]

[22.840811]

        let time = txn.get_changeset(&channel.changes, id, None)?.unwrap();

Replacement in libpijul/src/change.rs at line 386 [22.831311]

B:BD[22.841420] → [22.841420:841542]

        let mut cursor = txn.iter_dep(id);
        while let Some((id0, dep)) = txn.cursor_dep_next(&mut cursor.cursor) {

[22.841420]

[22.841542]

        let mut cursor = txn.iter_dep(id)?;
        while let Some(x) = txn.cursor_dep_next(&mut cursor.cursor)? {
            let (id0, dep) = x;

Replacement in libpijul/src/change.rs at line 395 [22.831311]

B:BD[22.841723] → [22.841723:841815]

            let time = if let Some(time) = txn.get_changeset(&channel.changes, dep, None) {

[22.841723]

[22.841815]

            let time = if let Some(time) = txn.get_changeset(&channel.changes, dep, None)? {

Replacement in libpijul/src/change.rs at line 411 [22.831311]
B:BD[22.842229] → [22.842229:842248]
```
    internal_deps_
```
[22.842229]
[22.842248]
```
    Ok(internal_deps_
```

Replacement in libpijul/src/change.rs at line 413 [22.831311]

B:BD[22.842269] → [22.842269:842337]

        .map(|id| txn.get_external(id).unwrap())
        .collect()

[22.842269]

[22.842337]

        .map(|id| txn.get_external(id).unwrap().unwrap())
        .collect())

Replacement in libpijul/src/change.rs at line 949 [22.831311]

B:BD[22.860210] → [22.860210:860276]

    fn globalize<T: TxnT>(&self, txn: &T) -> Atom<Option<Hash>> {

[22.860210]

[22.860276]

    fn globalize<T: GraphTxnT>(&self, txn: &T) -> Result<Atom<Option<Hash>>, T::GraphError> {

Replacement in libpijul/src/change.rs at line 958 [22.831311]
B:BD[22.860484] → [22.860484:860530]
```
            }) => Atom::NewVertex(NewVertex {
```
[22.860484]
[22.860530]
```
            }) => Ok(Atom::NewVertex(NewVertex {
```

Replacement in libpijul/src/change.rs at line 962 [22.831311]

B:BD[22.860639] → [22.860639:860716]

                        change: up.change.and_then(|a| txn.get_external(a)),

[22.860639]

[22.860716]

                        change: up.change.and_then(|a| txn.get_external(a).unwrap()),

Replacement in libpijul/src/change.rs at line 969 [22.831311]

B:BD[22.860923] → [22.860923:861002]

                        change: down.change.and_then(|a| txn.get_external(a)),

[22.860923]

[22.861002]

                        change: down.change.and_then(|a| txn.get_external(a).unwrap()),

Replacement in libpijul/src/change.rs at line 977 [22.831311]

B:BD[22.861217] → [22.861217:861293]

                    change: inode.change.and_then(|a| txn.get_external(a)),

[22.861217]

[22.861293]

                    change: inode.change.and_then(|a| txn.get_external(a).unwrap()),

Replacement in libpijul/src/change.rs at line 980 [22.831311]

B:BD[22.861348] → [22.861348:861443]

            }),
            Atom::EdgeMap(EdgeMap { edges, inode }) => Atom::EdgeMap(EdgeMap {

[22.861348]

[22.861443]

            })),
            Atom::EdgeMap(EdgeMap { edges, inode }) => Ok(Atom::EdgeMap(EdgeMap {

Replacement in libpijul/src/change.rs at line 988 [22.831311]

B:BD[22.861673] → [22.861673:861761]

                            change: edge.from.change.and_then(|a| txn.get_external(a)),

[22.861673]

[22.861761]

                            change: edge.from.change.and_then(|a| txn.get_external(a).unwrap()),

Replacement in libpijul/src/change.rs at line 992 [22.831311]

B:BD[22.861873] → [22.861873:861959]

                            change: edge.to.change.and_then(|a| txn.get_external(a)),

[22.861873]

[22.861959]

                            change: edge.to.change.and_then(|a| txn.get_external(a).unwrap()),

Replacement in libpijul/src/change.rs at line 997 [22.831311]

B:BD[22.862150] → [22.862150:862217]

                            if let Some(a) = txn.get_external(a) {

[22.862150]

[22.862217]

                            if let Some(a) = txn.get_external(a).unwrap() {

Replacement in libpijul/src/change.rs at line 1006 [22.831311]

B:BD[22.862500] → [22.862500:862576]

                    change: inode.change.and_then(|a| txn.get_external(a)),

[22.862500]

[22.862576]

                    change: inode.change.and_then(|a| txn.get_external(a).unwrap()),

Replacement in libpijul/src/change.rs at line 1009 [22.831311]
B:BD[22.862631] → [22.862631:862647]
```
            }),
```
[22.862631]
[22.862647]
```
            })),
```

Replacement in libpijul/src/change.rs at line 1049 [22.831311]

B:BD[22.864041] → [22.864041:864140]

    pub fn globalize<T: TxnT>(self, txn: &T) -> Record<Option<Hash>, Local> {
        match self {

[22.864041]

[22.864140]

    pub fn globalize<T: GraphTxnT>(
        self,
        txn: &T,
    ) -> Result<Record<Option<Hash>, Local>, T::GraphError> {
        Ok(match self {

Replacement in libpijul/src/change.rs at line 1055 [22.831311]

B:BD[22.864210] → [22.864210:864292]

                del: del.globalize(txn),
                add: add.globalize(txn),

[22.864210]

[22.864292]

                del: del.globalize(txn)?,
                add: add.globalize(txn)?,

Replacement in libpijul/src/change.rs at line 1064 [22.831311]

B:BD[22.864463] → [22.864463:864579]

                del: del.globalize(txn),
                contents: contents.as_ref().map(|del| del.globalize(txn)),

[22.864463]

[22.864579]

                del: del.globalize(txn)?,
                contents: contents.as_ref().map(|del| del.globalize(txn).unwrap()),

Replacement in libpijul/src/change.rs at line 1073 [22.831311]

B:BD[22.864756] → [22.864756:864876]

                undel: undel.globalize(txn),
                contents: contents.as_ref().map(|del| del.globalize(txn)),

[22.864756]

[22.864876]

                undel: undel.globalize(txn)?,
                contents: contents.as_ref().map(|del| del.globalize(txn).unwrap()),

Replacement in libpijul/src/change.rs at line 1078 [22.831311]
B:BD[22.864997] → [22.864997:865040]
```
                name: name.globalize(txn),
```
[22.864997]
[22.865040]
```
                name: name.globalize(txn)?,
```
Replacement in libpijul/src/change.rs at line 1082 [22.831311]
B:BD[22.865165] → [22.865165:865208]
```
                name: name.globalize(txn),
```
[22.865165]
[22.865208]
```
                name: name.globalize(txn)?,
```

Replacement in libpijul/src/change.rs at line 1091 [22.831311]

B:BD[22.865411] → [22.865411:865590]

                add_name: add_name.globalize(txn),
                add_inode: add_inode.globalize(txn),
                contents: contents.as_ref().map(|add| add.globalize(txn)),

[22.865411]

[22.865590]

                add_name: add_name.globalize(txn)?,
                add_inode: add_inode.globalize(txn)?,
                contents: contents.as_ref().map(|add| add.globalize(txn).unwrap()),

Replacement in libpijul/src/change.rs at line 1097 [22.831311]

B:BD[22.865688] → [22.865688:865735]

                change: change.globalize(txn),

[22.865688]

[22.865735]

                change: change.globalize(txn)?,

Replacement in libpijul/src/change.rs at line 1105 [22.831311]

B:BD[22.865922] → [22.865922:866026]

                change: change.globalize(txn),
                replacement: replacement.globalize(txn),

[22.865922]

[22.866026]

                change: change.globalize(txn)?,
                replacement: replacement.globalize(txn)?,

Replacement in libpijul/src/change.rs at line 1110 [22.831311]

B:BD[22.866153] → [22.866153:866200]

                change: change.globalize(txn),

[22.866153]

[22.866200]

                change: change.globalize(txn)?,

Replacement in libpijul/src/change.rs at line 1114 [22.831311]

B:BD[22.866331] → [22.866331:866378]

                change: change.globalize(txn),

[22.866331]

[22.866378]

                change: change.globalize(txn)?,

Replacement in libpijul/src/change.rs at line 1118 [22.831311]

B:BD[22.866501] → [22.866501:866548]

                change: change.globalize(txn),

[22.866501]

[22.866548]

                change: change.globalize(txn)?,

Replacement in libpijul/src/change.rs at line 1121 [22.831311]
B:BD[22.866586] → [22.866586:866596]
```
        }
```
[22.866586]
[22.866596]
```
        })
```

Replacement in libpijul/src/change.rs at line 1142 [22.831311]

B:BD[22.867173] → [22.867173:867206]

    pub fn make_change<T: TxnT>(

[22.867173]

[22.867206]

    pub fn make_change<T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>>(

Replacement in libpijul/src/change.rs at line 1149 [22.831311]

B:BD[22.867387] → [22.867387:867489]

    ) -> Self {
        let (dependencies, extra_known) = dependencies(txn, channel, changes.iter());

[22.867387]

[22.867489]

    ) -> Result<Self, TxnErr<T::DepsError>> {
        let (dependencies, extra_known) = dependencies(txn, &channel.borrow(), changes.iter())?;

Replacement in libpijul/src/change.rs at line 1158 [22.831311]
B:BD[22.867770] → [22.867770:867792]
```
        LocalChange {
```
[22.867770]
[22.867792]
```
        Ok(LocalChange {
```
Replacement in libpijul/src/change.rs at line 1171 [22.831311]
B:BD[22.868126] → [22.868126:868136]
```
        }
```
[22.868126]
[22.868136]
```
        })
```

Replacement in libpijul/src/change/text_changes.rs at line 155 [23.37976]

B:BD[23.42903] → [23.42903:42950]

    pub fn read_and_deps<R: BufRead, T: TxnT>(

[23.42903]

[23.42950]

    pub fn read_and_deps<
        R: BufRead,
        T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
    >(

Replacement in libpijul/src/change/text_changes.rs at line 165 [23.37976]

B:BD[23.43188] → [23.43188:43278]

        let (mut deps, extra) = dependencies(txn, channel, change.hashed.changes.iter());

[23.43188]

[23.43278]

        let (mut deps, extra) =
            dependencies(txn, &channel.borrow(), change.hashed.changes.iter()).unwrap();

Replacement in libpijul/src/apply.rs at line 22 [22.944089]

B:BD[23.93764] → [23.93764:93820]

pub enum LocalApplyError<TxnError: std::error::Error> {

[23.93764]

[23.93820]

pub enum LocalApplyError<TxnError: std::error::Error + 'static> {

Replacement in libpijul/src/apply.rs at line 29 [22.944089]

B:BD[23.94094] → [23.94094:94263]

    #[error(transparent)]
    Block(#[from] crate::pristine::BlockError),
    #[error(transparent)]
    InconsistentChange(#[from] crate::pristine::InconsistentChange),

[23.94094]

[23.94263]

    #[error("Block error: {:?}", block)]
    Block { block: Position<ChangeId> },
    #[error("Invalid change")]
    InvalidChange,

Deletion in libpijul/src/apply.rs at line 35 [22.944089]

B:BD[23.94266] → [21.17267:17434]

impl<E: std::error::Error> LocalApplyError<E> {
    const INCONSISTENT: Self =
        LocalApplyError::InconsistentChange(crate::pristine::InconsistentChange {});
}

Replacement in libpijul/src/apply.rs at line 39 [22.944089]

B:BD[23.94468] → [23.94468:94618]

            MissingError::Block(e) => LocalApplyError::Block(e),
            MissingError::Inconsistent(e) => LocalApplyError::InconsistentChange(e),

[23.94468]

[23.94618]

            MissingError::Block(e) => e.into(),
            MissingError::Inconsistent(_) => LocalApplyError::InvalidChange,
        }
    }
}
impl<T: std::error::Error> From<crate::pristine::InconsistentChange<T>> for LocalApplyError<T> {
    fn from(err: crate::pristine::InconsistentChange<T>) -> Self {
        match err {
            InconsistentChange::Txn(e) => LocalApplyError::Txn(e),
            _ => LocalApplyError::InvalidChange,
        }
    }
}
impl<T: std::error::Error> From<crate::pristine::TxnErr<T>> for LocalApplyError<T> {
    fn from(err: crate::pristine::TxnErr<T>) -> Self {
        LocalApplyError::Txn(err.0)
    }
}
impl<C: std::error::Error, T: std::error::Error> From<crate::pristine::TxnErr<T>>
    for ApplyError<C, T>
{
    fn from(err: crate::pristine::TxnErr<T>) -> Self {
        LocalApplyError::Txn(err.0).into()
    }
}
impl<T: std::error::Error> From<crate::pristine::BlockError<T>> for LocalApplyError<T> {
    fn from(err: crate::pristine::BlockError<T>) -> Self {
        match err {
            BlockError::Txn(e) => LocalApplyError::Txn(e),
            BlockError::Block { block } => LocalApplyError::Block { block },

Replacement in libpijul/src/apply.rs at line 87 [22.944089]

B:BD[22.944880] → [23.94638:94699]

) -> Result<(u64, Merkle), ApplyError<P::Error, T::Error>> {

[22.944880]

[22.944924]

) -> Result<(u64, Merkle), ApplyError<P::Error, T::GraphError>> {

Replacement in libpijul/src/apply.rs at line 97 [22.944089]

B:BD[22.945203] → [22.945203:945329]

        if let Some(int) = txn.get_internal(hash) {
            if txn.get_changeset(&channel.changes, int, None).is_some() {

[22.945203]

[22.945329]

        if let Some(int) = txn.get_internal(hash)? {
            if txn.get_changeset(&channel.changes, int, None)?.is_some() {

Replacement in libpijul/src/apply.rs at line 105 [22.944089]

B:BD[22.945450] → [22.945450:945511]

    let internal = if let Some(p) = txn.get_internal(hash) {

[22.945450]

[22.945511]

    let internal = if let Some(p) = txn.get_internal(hash)? {

Replacement in libpijul/src/apply.rs at line 108 [22.944089]

B:BD[22.945534] → [26.67015:67075]

B:BD[26.67075] → [23.94854:94940]

        let internal: ChangeId = make_changeid(txn, &hash);
        register_change(txn, internal, hash, &change).map_err(LocalApplyError::Txn)?;

[22.945534]

[22.945648]

        let internal: ChangeId = make_changeid(txn, &hash)?;
        register_change(txn, internal, hash, &change)?;

Replacement in libpijul/src/apply.rs at line 130 [22.944089]
B:BD[22.946111] → [23.95086:95136]
```
) -> Result<(), ApplyError<P::Error, T::Error>> {
```
[22.946111]
[22.946144]
```
) -> Result<(), ApplyError<P::Error, T::GraphError>> {
```

Replacement in libpijul/src/apply.rs at line 143 [22.944089]

B:BD[3.182] → [3.182:244]

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

[3.182]

[3.244]

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

Replacement in libpijul/src/apply.rs at line 145 [22.944089]

B:BD[3.267] → [3.267:337]

                    .get_changeset(&channel.changes, change_id, None)

[3.267]

[3.337]

                    .get_changeset(&channel.changes, change_id, None)?

Replacement in libpijul/src/apply.rs at line 160 [22.944089]

B:BD[22.946763] → [22.946763:946906]

            let applied = if let Some(int) = txn.get_internal(hash) {
                txn.get_changeset(&channel.changes, int, None).is_some()

[22.946763]

[22.946906]

            let applied = if let Some(int) = txn.get_internal(hash)? {
                txn.get_changeset(&channel.changes, int, None)?.is_some()

Replacement in libpijul/src/apply.rs at line 166 [22.944089]

B:BD[22.946990] → [22.946990:947063]

                let internal = if let Some(p) = txn.get_internal(hash) {

[22.946990]

[22.947063]

                let internal = if let Some(p) = txn.get_internal(hash)? {

Replacement in libpijul/src/apply.rs at line 169 [22.944089]

B:BD[22.947110] → [26.67132:67204]

B:BD[26.67204] → [23.95220:95318]

                    let internal: ChangeId = make_changeid(txn, &hash);
                    register_change(txn, internal, hash, &change).map_err(LocalApplyError::Txn)?;

[22.947110]

[22.947248]

                    let internal: ChangeId = make_changeid(txn, &hash)?;
                    register_change(txn, internal, hash, &change)?;

Replacement in libpijul/src/apply.rs at line 188 [22.944089]

B:BD[22.947938] → [23.95319:95380]

) -> Result<(u64, Merkle), ApplyError<P::Error, T::Error>> {

[22.947938]

[22.947982]

) -> Result<(u64, Merkle), ApplyError<P::Error, T::GraphError>> {

Replacement in libpijul/src/apply.rs at line 199 [22.944089]
B:BD[22.948278] → [23.95381:95431]
```
) -> Result<(), ApplyError<P::Error, T::Error>> {
```
[22.948278]
[22.948311]
```
) -> Result<(), ApplyError<P::Error, T::GraphError>> {
```
Replacement in libpijul/src/apply.rs at line 210 [22.944089]
B:BD[22.948511] → [66.184:224]
```
fn apply_change_to_channel<T: MutTxnT>(
```
[22.948456]
[22.948727]
```
fn apply_change_to_channel<T: ChannelMutTxnT>(
```
Replacement in libpijul/src/apply.rs at line 217 [22.944089]
B:BD[22.948861] → [23.95432:95488]
```
) -> Result<(u64, Merkle), LocalApplyError<T::Error>> {
```
[22.948861]
[22.948905]
```
) -> Result<(u64, Merkle), LocalApplyError<T::GraphError>> {
```

Replacement in libpijul/src/apply.rs at line 220 [22.944089]

B:BD[22.948963] → [23.95489:95750]

    let merkle = if let Some(m) = txn
        .put_changes(channel, change_id, channel.apply_counter, hash)
        .map_err(LocalApplyError::Txn)?
    {
        m
    } else {
        return Err(LocalApplyError::ChangeAlreadyOnChannel { hash: *hash });
    };

[22.948963]

[22.949195]

    let merkle =
        if let Some(m) = txn.put_changes(channel, change_id, channel.apply_counter, hash)? {
            m
        } else {
            return Err(LocalApplyError::ChangeAlreadyOnChannel { hash: *hash });
        };

Replacement in libpijul/src/apply.rs at line 232 [22.944089]

B:BD[22.949433] → [22.949433:949531]

                Atom::NewVertex(ref n) => put_newvertex(txn, channel, change, ws, change_id, n)?,

[22.949433]

[22.949531]

                Atom::NewVertex(ref n) => {
                    put_newvertex(txn, &mut channel.graph, change, ws, change_id, n)?
                }

Replacement in libpijul/src/apply.rs at line 240 [22.944089]

B:BD[22.949815] → [22.949815:949856]

                                channel,

[22.949815]

[22.949856]

                                &mut channel.graph,

Replacement in libpijul/src/apply.rs at line 245 [22.944089]

B:BD[22.950014] → [23.95751:95841]

                                |_, _, _, _| Ok::<bool, LocalApplyError<T::Error>>(true),

[22.950014]

[21.17435]

                                |_, _, _, _| Ok::<bool, LocalApplyError<T::GraphError>>(true),

Replacement in libpijul/src/apply.rs at line 259 [22.944089]

B:BD[62.886] → [62.886:981]

B:BD[62.981] → [23.95842:95914]

∅:D[23.95914] → [62.1018:1047]

B:BD[62.1018] → [62.1018:1047]

                        put_newedge(txn, channel, ws, change_id, n.inode, edge, |_, _, _, _| {
                            Ok::<bool, LocalApplyError<T::Error>>(true)
                        })?;

[62.886]

[62.1126]

                        put_newedge(
                            txn,
                            &mut channel.graph,
                            ws,
                            change_id,
                            n.inode,
                            edge,
                            |_, _, _, _| Ok::<bool, LocalApplyError<T::GraphError>>(true),
                        )?;

Replacement in libpijul/src/apply.rs at line 270 [22.944089]

B:BD[62.1231] → [62.1231:1268]

                            channel,

[62.1231]

[62.1268]

                            &mut channel.graph,

Replacement in libpijul/src/apply.rs at line 285 [22.944089]

B:BD[22.951686] → [21.17468:17531]

    clean_obsolete_pseudo_edges(txn, channel, ws, change_id)?;

[22.951686]

[22.951738]

    clean_obsolete_pseudo_edges(txn, &mut channel.graph, ws, change_id)?;

Replacement in libpijul/src/apply.rs at line 288 [22.944089]

B:BD[22.951780] → [22.951780:951847]

B:BD[22.951847] → [21.17532:17576]

    repair_missing_contexts(txn, channel, ws, change_id, change)?;
    repair_cyclic_paths(txn, channel, ws)?;

[22.951780]

[22.951910]

    repair_missing_contexts(txn, &mut channel.graph, ws, change_id, change)?;
    repair_cyclic_paths(txn, &mut channel.graph, ws)?;

Replacement in libpijul/src/apply.rs at line 300 [22.944089]

B:BD[22.952448] → [22.952448:952490]

pub fn apply_local_change_ws<T: MutTxnT>(

[22.952448]

[22.952490]

pub fn apply_local_change_ws<
    T: ChannelMutTxnT
        + DepsMutTxnT<DepsError = <T as GraphTxnT>::GraphError>
        + TreeMutTxnT<TreeError = <T as GraphTxnT>::GraphError>,
>(

Replacement in libpijul/src/apply.rs at line 311 [22.944089]
B:BD[22.952657] → [23.96185:96241]
```
) -> Result<(u64, Merkle), LocalApplyError<T::Error>> {
```
[22.952657]
[22.952760]
```
) -> Result<(u64, Merkle), LocalApplyError<T::GraphError>> {
```

Replacement in libpijul/src/apply.rs at line 313 [22.944089]

B:BD[22.952806] → [26.67273:67329]

    let internal: ChangeId = make_changeid(txn, &hash);

[22.952806]

[67.0]

    let internal: ChangeId = make_changeid(txn, &hash)?;

Replacement in libpijul/src/apply.rs at line 319 [22.944089]

B:BD[67.114] → [67.114:240]

        if let Some(int) = txn.get_internal(hash) {
            if txn.get_changeset(&channel.changes, int, None).is_some() {

[67.114]

[67.240]

        if let Some(int) = txn.get_internal(hash)? {
            if txn.get_changeset(&channel.changes, int, None)?.is_some() {

Replacement in libpijul/src/apply.rs at line 327 [22.944089]

B:BD[67.361] → [23.96317:96399]

    register_change(txn, internal, hash, &change).map_err(LocalApplyError::Txn)?;

[67.361]

[66.227]

    register_change(txn, internal, hash, &change)?;

Replacement in libpijul/src/apply.rs at line 331 [22.944089]

B:BD[22.953296] → [22.953296:953352]

        update_inode(txn, &channel, internal, update)?;

[22.953296]

[22.953352]

        update_inode(txn, &channel.graph, internal, update)?;

Replacement in libpijul/src/apply.rs at line 337 [22.944089]

B:BD[22.953441] → [22.953441:953480]

pub fn apply_local_change<T: MutTxnT>(

[22.953441]

[22.953480]

pub fn apply_local_change<
    T: ChannelMutTxnT
        + DepsMutTxnT<DepsError = <T as GraphTxnT>::GraphError>
        + TreeMutTxnT<TreeError = <T as GraphTxnT>::GraphError>,
>(

Replacement in libpijul/src/apply.rs at line 347 [22.944089]
B:BD[22.953616] → [23.96400:96456]
```
) -> Result<(u64, Merkle), LocalApplyError<T::Error>> {
```
[22.953616]
[22.953660]
```
) -> Result<(u64, Merkle), LocalApplyError<T::GraphError>> {
```
Replacement in libpijul/src/apply.rs at line 358 [22.944089]
∅:D[41.3408] → [22.953864:953893]
B:BD[22.953864] → [22.953864:953893]
```
fn update_inode<T: MutTxnT>(
```
[41.3408]
[22.953893]
```
fn update_inode<T: GraphTxnT + TreeMutTxnT<TreeError = <T as GraphTxnT>::GraphError>>(
```
Replacement in libpijul/src/apply.rs at line 360 [22.944089]
B:BD[22.953910] → [22.953910:953936]
```
    channel: &Channel<T>,
```
[22.953910]
[22.953936]
```
    channel: &T::Graph,
```
Replacement in libpijul/src/apply.rs at line 363 [22.944089]
B:BD[22.953986] → [23.96457:96502]
```
) -> Result<(), LocalApplyError<T::Error>> {
```
[22.953986]
[22.954019]
```
) -> Result<(), LocalApplyError<T::TreeError>> {
```

Replacement in libpijul/src/apply.rs at line 372 [22.944089]

B:BD[22.954317] → [22.954317:954389]

                .get_graph(&channel.graph, vertex.inode_vertex(), None)

[22.954317]

[22.954389]

                .get_graph(&channel, vertex.inode_vertex(), None)?

Replacement in libpijul/src/apply.rs at line 376 [22.944089]

B:BD[22.954497] → [23.96503:96591]

                put_inodes_with_rev(txn, inode, vertex).map_err(LocalApplyError::Txn)?;

[22.954497]

[22.954554]

                put_inodes_with_rev(txn, inode, vertex)?;

Replacement in libpijul/src/apply.rs at line 382 [22.944089]

B:BD[22.954777] → [22.954777:954864]

B:BD[22.954864] → [23.96592:96691]

            if let Some(parent) = txn.get_revtree(inode, None).map(|x| x.to_owned()) {
                del_tree_with_rev(txn, parent.as_file_id(), inode).map_err(LocalApplyError::Txn)?;

[22.954777]

[22.954997]

            if let Some(parent) = txn.get_revtree(inode, None)?.map(|x| x.to_owned()) {
                del_tree_with_rev(txn, parent.as_file_id(), inode)?;

Replacement in libpijul/src/apply.rs at line 393 [22.944089]

B:BD[22.955259] → [23.96692:96751]

∅:D[23.96751] → [22.955275:955339]

B:BD[22.955275] → [22.955275:955339]

B:BD[22.955339] → [23.96752:96840]

            )
            .map_err(LocalApplyError::Txn)?;
            if let Some(vertex) = txn.get_inodes(inode, None) {
                del_inodes_with_rev(txn, inode, vertex).map_err(LocalApplyError::Txn)?;

[22.955259]

[22.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 402 [22.944089]
∅:D[41.3592] → [22.955548:955578]
B:BD[22.955548] → [22.955548:955578]
```
fn put_newvertex<T: MutTxnT>(
```
[41.3592]
[22.955578]
```
fn put_newvertex<T: GraphMutTxnT>(
```
Replacement in libpijul/src/apply.rs at line 404 [22.944089]
B:BD[22.955595] → [22.955595:955625]
```
    channel: &mut Channel<T>,
```
[22.955595]
[22.955625]
```
    graph: &mut T::Graph,
```
Replacement in libpijul/src/apply.rs at line 409 [22.944089]
B:BD[22.955721] → [23.96841:96886]
```
) -> Result<(), LocalApplyError<T::Error>> {
```
[22.955721]
[22.955754]
```
) -> Result<(), LocalApplyError<T::GraphError>> {
```

Replacement in libpijul/src/apply.rs at line 422 [22.944089]

B:BD[26.67490] → [21.17599:17747]

        if put_up_context(txn, channel, ch, ws, up)? && n.flag.contains(EdgeFlags::FOLDER) {
            return Err(LocalApplyError::INCONSISTENT);

[26.67490]

[21.17747]

        if put_up_context(txn, graph, ch, ws, up)? && n.flag.contains(EdgeFlags::FOLDER) {
            return Err(LocalApplyError::InvalidChange);

Replacement in libpijul/src/apply.rs at line 429 [22.944089]

B:BD[21.17793] → [21.17793:17849]

            return Err((InconsistentChange {}).into());

[21.17793]

[21.17849]

            return Err(LocalApplyError::InvalidChange);

Replacement in libpijul/src/apply.rs at line 431 [22.944089]

B:BD[21.17859] → [21.17859:18012]

        if put_down_context(txn, channel, ch, ws, down)? && !n.flag.contains(EdgeFlags::FOLDER) {
            return Err(LocalApplyError::INCONSISTENT);

[21.17859]

[21.18012]

        if put_down_context(txn, graph, ch, ws, down)? && !n.flag.contains(EdgeFlags::FOLDER) {
            return Err(LocalApplyError::InvalidChange);

Replacement in libpijul/src/apply.rs at line 442 [22.944089]

B:BD[21.18139] → [21.18139:18218]

∅:D[21.18218] → [23.96963:97016]

B:BD[23.96963] → [23.96963:97016]

                put_graph_with_rev(txn, channel, up_flag, up, vertex, *change)
                    .map_err(LocalApplyError::Txn)?;

[21.18139]

[22.956703]

                put_graph_with_rev(txn, graph, up_flag, up, vertex, *change)?;

Replacement in libpijul/src/apply.rs at line 445 [22.944089]

B:BD[22.956727] → [21.18219:18352]

        put_graph_with_rev(txn, channel, n.flag | EdgeFlags::BLOCK, up, vertex, change)
            .map_err(LocalApplyError::Txn)?;

[22.956727]

[22.956816]

        put_graph_with_rev(txn, graph, n.flag | EdgeFlags::BLOCK, up, vertex, change)?;

Replacement in libpijul/src/apply.rs at line 454 [22.944089]

B:BD[22.956966] → [21.18459:18533]

∅:D[21.18533] → [23.97131:97176]

B:BD[23.97131] → [23.97131:97176]

        put_graph_with_rev(txn, channel, down_flag, vertex, down, change)
            .map_err(LocalApplyError::Txn)?;

[22.956966]

[21.18534]

        put_graph_with_rev(txn, graph, down_flag, vertex, down, change)?;

Replacement in libpijul/src/apply.rs at line 463 [22.944089]
∅:D[43.1048] → [22.957608:957639]
B:BD[22.957608] → [22.957608:957639]
```
fn put_up_context<T: MutTxnT>(
```
[43.1048]
[22.957639]
```
fn put_up_context<T: GraphMutTxnT>(
```
Replacement in libpijul/src/apply.rs at line 465 [22.944089]
B:BD[22.957656] → [22.957656:957686]
```
    channel: &mut Channel<T>,
```
[22.957656]
[22.957686]
```
    graph: &mut T::Graph,
```
Replacement in libpijul/src/apply.rs at line 469 [22.944089]
B:BD[22.957790] → [21.18618:18665]
```
) -> Result<bool, LocalApplyError<T::Error>> {
```
[22.957790]
[22.957823]
```
) -> Result<bool, LocalApplyError<T::GraphError>> {
```
Replacement in libpijul/src/apply.rs at line 474 [22.944089]
B:BD[22.957945] → [26.68284:68335]
```
        let k = find_block_end(txn, channel, up)?;
```
[22.957945]
[22.957995]
```
        let k = find_block_end(txn, graph, up)?;
```

Replacement in libpijul/src/apply.rs at line 482 [22.944089]

∅:D[21.18835] → [23.97283:97363]

B:BD[22.958453] → [23.97283:97363]

            split_block(txn, channel, k, up.pos).map_err(LocalApplyError::Txn)?

[21.18835]

[22.958502]

            split_block(txn, graph, k, up.pos, &mut ws.adjbuf)?

Replacement in libpijul/src/apply.rs at line 494 [22.944089]

∅:D[21.18871] → [26.68505:68579]

B:BD[26.68505] → [26.68505:68579]

    for parent in iter_adjacent(txn, &channel, up_vertex, flag0, flag1) {

[21.18871]

[21.18872]

    for parent in iter_adjacent(txn, graph, up_vertex, flag0, flag1)? {
        let parent = parent?;

Replacement in libpijul/src/apply.rs at line 501 [22.944089]

B:BD[26.68768] → [26.68768:68849]

            let introduced_by = txn.get_external(parent.introduced_by).unwrap();

[26.68706]

[26.68849]

            let introduced_by = txn.get_external(parent.introduced_by)?.unwrap();

Replacement in libpijul/src/apply.rs at line 511 [22.944089]
∅:D[43.1050] → [22.959262:959295]
B:BD[22.959262] → [22.959262:959295]
```
fn put_down_context<T: MutTxnT>(
```
[43.1050]
[22.959295]
```
fn put_down_context<T: GraphMutTxnT>(
```
Replacement in libpijul/src/apply.rs at line 513 [22.944089]
B:BD[22.959312] → [22.959312:959342]
```
    channel: &mut Channel<T>,
```
[22.959312]
[22.959342]
```
    graph: &mut T::Graph,
```
Replacement in libpijul/src/apply.rs at line 517 [22.944089]
B:BD[22.959448] → [21.19058:19105]
∅:D[21.19105] → [26.69263:69309]
∅:D[23.97423] → [26.69263:69309]
B:BD[22.959495] → [26.69263:69309]
```
) -> Result<bool, LocalApplyError<T::Error>> {
    let k = find_block(txn, &channel, down)?;
```
[22.959448]
[22.959540]
```
) -> Result<bool, LocalApplyError<T::GraphError>> {
    let k = find_block(txn, &graph, down)?;
```

Replacement in libpijul/src/apply.rs at line 525 [22.944089]

∅:D[21.19263] → [23.97424:97502]

B:BD[22.960068] → [23.97424:97502]

        split_block(txn, channel, k, down.pos).map_err(LocalApplyError::Txn)?

[21.19263]

[22.960115]

        split_block(txn, graph, k, down.pos, &mut ws.adjbuf)?

Replacement in libpijul/src/apply.rs at line 537 [22.944089]

∅:D[21.19295] → [26.69361:69437]

B:BD[22.960393] → [26.69361:69437]

    for parent in iter_adjacent(txn, &channel, down_vertex, flag0, flag1) {

[21.19295]

[21.19296]

    for parent in iter_adjacent(txn, &graph, down_vertex, flag0, flag1)? {
        let parent = parent?;

Replacement in libpijul/src/apply.rs at line 542 [22.944089]

B:BD[22.960679] → [22.960679:960764]

                let introduced_by = txn.get_external(parent.introduced_by).unwrap();

[22.960613]

[22.960764]

                let introduced_by = txn.get_external(parent.introduced_by)?.unwrap();

Insertion in libpijul/src/apply.rs at line 563 [22.944089]
[22.961591]
[22.961591]
```
    adjbuf: Vec<Edge>,
```
Insertion in libpijul/src/apply.rs at line 579 [22.944089]
[22.962286]
[22.962286]
```
        self.adjbuf.clear();
```

Replacement in libpijul/src/apply.rs at line 589 [22.944089]

B:BD[22.962629] → [22.962629:962669]

        assert!(self.rooted.is_empty())

[22.962629]

[22.962669]

        assert!(self.rooted.is_empty());
        assert!(self.adjbuf.is_empty());

Replacement in libpijul/src/apply.rs at line 596 [22.944089]
B:BD[22.962811] → [22.962811:962841]
```
    channel: &mut Channel<T>,
```
[22.962811]
[22.962841]
```
    graph: &mut T::Graph,
```

Replacement in libpijul/src/apply.rs at line 604 [22.944089]

B:BD[22.963010] → [22.963010:963026]

B:BD[22.963026] → [23.97561:97692]

    T: MutTxnT,
    E: From<LocalApplyError<T::Error>>,
    F: Fn(&mut T, &mut Channel<T>, Vertex<ChangeId>, Vertex<ChangeId>) -> Result<bool, E>,

[22.963010]

[22.963317]

    T: GraphMutTxnT,
    E: From<LocalApplyError<T::GraphError>> + From<TxnErr<T::GraphError>>,
    F: Fn(&mut T, &mut T::Graph, Vertex<ChangeId>, Vertex<ChangeId>) -> Result<bool, E>,

Replacement in libpijul/src/apply.rs at line 611 [22.944089]

B:BD[23.97720] → [23.97720:97825]

            .load_graph(txn, channel, inode)
            .map_err(LocalApplyError::InconsistentChange)?;

[23.97720]

[22.963425]

            .load_graph(txn, graph, inode)
            .map_err(|_| LocalApplyError::InvalidChange)?;

Replacement in libpijul/src/apply.rs at line 617 [22.944089]

B:BD[21.19664] → [21.19664:19722]

        return Err(LocalApplyError::INCONSISTENT.into());

[21.19664]

[21.19722]

        return Err(LocalApplyError::InvalidChange.into());

Replacement in libpijul/src/apply.rs at line 622 [22.944089]

∅:D[21.19814] → [26.69656:69741]

B:BD[22.963553] → [26.69656:69741]

    let n_introduced_by = if let Some(n) = internal(txn, &n.introduced_by, change) {

[21.19814]

[22.963637]

    let n_introduced_by = if let Some(n) = internal(txn, &n.introduced_by, change)? {

Replacement in libpijul/src/apply.rs at line 625 [22.944089]

B:BD[22.963660] → [21.19815:19873]

        return Err(LocalApplyError::INCONSISTENT.into());

[22.963660]

[22.963721]

        return Err(LocalApplyError::InvalidChange.into());

Replacement in libpijul/src/apply.rs at line 628 [22.944089]

B:BD[22.963729] → [22.963729:963911]

    let mut source = find_source_vertex(txn, channel, &n.from, change, inode, n.flag, ws)?;
    let mut target = find_target_vertex(txn, channel, &n.to, change, inode, n.flag, ws)?;

[22.963729]

[22.963911]

    let mut source = find_source_vertex(txn, graph, &n.from, change, inode, n.flag, ws)?;
    let mut target = find_target_vertex(txn, graph, &n.to, change, inode, n.flag, ws)?;

Replacement in libpijul/src/apply.rs at line 639 [22.944089]

∅:D[21.20045] → [23.97954:98042]

B:BD[22.964639] → [23.97954:98042]

            split_block(txn, channel, target, n.to.end).map_err(LocalApplyError::Txn)?;

[21.20045]

[22.964696]

            split_block(txn, graph, target, n.to.end, &mut ws.adjbuf)
                .map_err(LocalApplyError::from)?;

Replacement in libpijul/src/apply.rs at line 645 [22.944089]

B:BD[22.964790] → [22.964790:964858]

            collect_pseudo_edges(txn, channel, ws, inode, target)?;

[22.964790]

[22.964858]

            collect_pseudo_edges(txn, graph, ws, inode, target).map_err(LocalApplyError::from)?;

Replacement in libpijul/src/apply.rs at line 647 [22.944089]

B:BD[22.964911] → [22.964911:964985]

                reconnect_pseudo_edges(txn, channel, inode, ws, target)?;

[22.964911]

[22.964985]

                reconnect_pseudo_edges(txn, graph, inode, ws, target)?;

Replacement in libpijul/src/apply.rs at line 653 [22.944089]

B:BD[22.965043] → [21.20079:20165]

∅:D[21.20165] → [23.98139:98184]

B:BD[23.98139] → [23.98139:98184]

B:BD[22.965742] → [22.965742:965798]

B:BD[22.965798] → [23.98185:98262]

B:BD[23.98262] → [23.98262:98311]

        del_graph_with_rev(txn, channel, n.previous, source, target, n_introduced_by)
            .map_err(LocalApplyError::Txn)?;
        if apply_check(txn, channel, source, target)? {
            put_graph_with_rev(txn, channel, n.flag, source, target, change)
                .map_err(LocalApplyError::Txn)?;

[22.965043]

[22.965876]

        del_graph_with_rev(txn, graph, n.previous, source, target, n_introduced_by)?;
        if apply_check(txn, graph, source, target)? {
            put_graph_with_rev(txn, graph, n.flag, source, target, change)?;

Replacement in libpijul/src/apply.rs at line 665 [22.944089]

B:BD[22.966024] → [23.98312:98406]

        target = find_block(txn, channel, target.end_pos()).map_err(LocalApplyError::Block)?;

[22.966024]

[22.966085]

        target = find_block(txn, graph, target.end_pos()).map_err(LocalApplyError::from)?;

Replacement in libpijul/src/apply.rs at line 671 [22.944089]
B:BD[22.966196] → [22.966196:966231]
```
fn find_source_vertex<T: MutTxnT>(
```
[22.966141]
[22.966231]
```
fn find_source_vertex<T: GraphMutTxnT>(
```
Replacement in libpijul/src/apply.rs at line 673 [22.944089]
B:BD[22.966248] → [22.966248:966278]
```
    channel: &mut Channel<T>,
```
[22.966248]
[22.966278]
```
    channel: &mut T::Graph,
```

Replacement in libpijul/src/apply.rs at line 679 [22.944089]

B:BD[22.966415] → [23.98407:98466]

) -> Result<Vertex<ChangeId>, LocalApplyError<T::Error>> {

[22.966415]

[22.966462]

) -> Result<Vertex<ChangeId>, LocalApplyError<T::GraphError>> {

Replacement in libpijul/src/apply.rs at line 686 [22.944089]

∅:D[21.20332] → [23.98467:98551]

B:BD[22.967280] → [23.98467:98551]

        split_block(txn, channel, source, from.pos).map_err(LocalApplyError::Txn)?;

[21.20332]

[22.967333]

        split_block(txn, channel, source, from.pos, &mut ws.adjbuf)?;

Replacement in libpijul/src/apply.rs at line 692 [22.944089]
B:BD[22.967388] → [22.967388:967423]
```
fn find_target_vertex<T: MutTxnT>(
```
[22.967388]
[22.967423]
```
fn find_target_vertex<T: GraphMutTxnT>(
```
Replacement in libpijul/src/apply.rs at line 694 [22.944089]
B:BD[22.967440] → [22.967440:967470]
```
    channel: &mut Channel<T>,
```
[22.967440]
[22.967470]
```
    channel: &mut T::Graph,
```

Replacement in libpijul/src/apply.rs at line 700 [22.944089]

B:BD[22.967603] → [23.98552:98611]

) -> Result<Vertex<ChangeId>, LocalApplyError<T::Error>> {

[22.967603]

[26.70187]

) -> Result<Vertex<ChangeId>, LocalApplyError<T::GraphError>> {

Replacement in libpijul/src/apply.rs at line 708 [22.944089]

∅:D[21.20449] → [23.98612:98696]

B:BD[22.968473] → [23.98612:98696]

        split_block(txn, channel, target, to.start).map_err(LocalApplyError::Txn)?;

[21.20449]

[22.968526]

        split_block(txn, channel, target, to.start, &mut ws.adjbuf)?;

Replacement in libpijul/src/apply.rs at line 714 [22.944089]
∅:D[43.1054] → [22.968637:968674]
B:BD[22.968637] → [22.968637:968674]
```
fn collect_pseudo_edges<T: MutTxnT>(
```
[43.1054]
[22.968674]
```
fn collect_pseudo_edges<T: GraphMutTxnT>(
```
Replacement in libpijul/src/apply.rs at line 716 [22.944089]
B:BD[22.968691] → [22.968691:968721]
```
    channel: &mut Channel<T>,
```
[22.968691]
[22.968721]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/apply.rs at line 720 [22.944089]
B:BD[22.968808] → [23.98697:98742]
```
) -> Result<(), LocalApplyError<T::Error>> {
```
[22.968808]
[26.70362]
```
) -> Result<(), LocalApplyError<T::GraphError>> {
```
Replacement in libpijul/src/apply.rs at line 727 [22.944089]
B:BD[22.968977] → [22.968977:968985]
```
    ) {
```
[22.968977]
[22.968985]
```
    )? {
        let e = e?;
```

Replacement in libpijul/src/apply.rs at line 733 [22.944089]

B:BD[26.70467] → [26.70467:70514]

                if is_alive(txn, channel, p) {

[26.70467]

[22.969250]

                if is_alive(txn, channel, p)? {

Replacement in libpijul/src/apply.rs at line 748 [22.944089]
∅:D[43.1056] → [22.969636:969675]
B:BD[22.969636] → [22.969636:969675]
```
fn reconnect_pseudo_edges<T: MutTxnT>(
```
[43.1056]
[22.969675]
```
fn reconnect_pseudo_edges<T: GraphMutTxnT>(
```
Replacement in libpijul/src/apply.rs at line 750 [22.944089]
B:BD[22.969692] → [22.969692:969722]
```
    channel: &mut Channel<T>,
```
[22.969692]
[22.969722]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/apply.rs at line 754 [22.944089]
B:BD[22.969811] → [23.98743:98788]
```
) -> Result<(), LocalApplyError<T::Error>> {
```
[22.969811]
[21.20450]
```
) -> Result<(), LocalApplyError<T::GraphError>> {
```

Replacement in libpijul/src/apply.rs at line 759 [22.944089]

B:BD[21.20509] → [21.20509:20572]

    let (graph, vids) = ws.missing_context.graphs.get(inode)?;

[21.20509]

[22.970270]

    let (graph, vids) = if let Some(x) = ws.missing_context.graphs.get(inode) {
        x
    } else {
        return Err(LocalApplyError::InvalidChange.into());
    };

Replacement in libpijul/src/apply.rs at line 779 [22.944089]

B:BD[21.20607] → [21.20607:20657]

        debug_assert!(is_alive(txn, channel, p));

[21.20607]

[21.20657]

        debug_assert!(is_alive(txn, channel, p).unwrap());

Replacement in libpijul/src/apply.rs at line 782 [22.944089]

B:BD[21.20720] → [21.20720:20868]

∅:D[21.20868] → [23.98933:98986]

B:BD[23.98933] → [23.98933:98986]

                debug_assert!(is_alive(txn, channel, c));
                put_graph_with_rev(txn, channel, EdgeFlags::PSEUDO, p, c, ChangeId::ROOT)
                    .map_err(LocalApplyError::Txn)?;

[21.20720]

[22.971153]

                debug_assert!(is_alive(txn, channel, c).unwrap());
                put_graph_with_rev(txn, channel, EdgeFlags::PSEUDO, p, c, ChangeId::ROOT)?;

Replacement in libpijul/src/apply.rs at line 790 [22.944089]
∅:D[43.1058] → [22.971251:971306]
B:BD[22.971251] → [22.971251:971306]
```
pub(crate) fn clean_obsolete_pseudo_edges<T: MutTxnT>(
```
[43.1058]
[22.971306]
```
pub(crate) fn clean_obsolete_pseudo_edges<T: GraphMutTxnT>(
```
Replacement in libpijul/src/apply.rs at line 792 [22.944089]
B:BD[22.971323] → [22.971323:971353]
```
    channel: &mut Channel<T>,
```
[22.971323]
[22.971353]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/apply.rs at line 795 [22.944089]
∅:D[21.20894] → [23.98987:99032]
B:BD[22.971377] → [23.98987:99032]
```
) -> Result<(), LocalApplyError<T::Error>> {
```
[21.20894]
[22.971451]
```
) -> Result<(), LocalApplyError<T::GraphError>> {
```

Replacement in libpijul/src/apply.rs at line 808 [22.944089]

B:BD[22.972426] → [26.70889:70993]

        let a_is_alive = is_alive(txn, channel, a);
        let b_is_alive = is_alive(txn, channel, b);

[22.972051]

[21.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 820 [22.944089]
B:BD[21.21176] → [21.21176:21227]
```
        )
        .map_err(LocalApplyError::Txn)?;
```
[21.21176]
[22.972853]
```
        )?;
```
Replacement in libpijul/src/apply.rs at line 848 [22.944089]
∅:D[43.1060] → [22.974306:974346]
B:BD[22.974306] → [22.974306:974346]
```
fn repair_missing_contexts<T: MutTxnT>(
```
[43.1060]
[22.974346]
```
fn repair_missing_contexts<T: GraphMutTxnT>(
```
Replacement in libpijul/src/apply.rs at line 850 [22.944089]
B:BD[22.974363] → [22.974363:974393]
```
    channel: &mut Channel<T>,
```
[22.974363]
[22.974393]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/apply.rs at line 854 [22.944089]
B:BD[22.974463] → [23.99411:99456]
```
) -> Result<(), LocalApplyError<T::Error>> {
```
[22.974463]
[22.974496]
```
) -> Result<(), LocalApplyError<T::GraphError>> {
```
Replacement in libpijul/src/apply.rs at line 881 [22.944089]
B:BD[43.1062] → [21.22106:22151]
```
fn repair_new_vertex_context_up<T: MutTxnT>(
```
[43.1062]
[21.22151]
```
fn repair_new_vertex_context_up<T: GraphMutTxnT>(
```
Replacement in libpijul/src/apply.rs at line 883 [22.944089]
B:BD[21.22168] → [21.22168:22198]
```
    channel: &mut Channel<T>,
```
[21.22168]
[21.22198]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/apply.rs at line 888 [22.944089]
B:BD[21.22310] → [21.22310:22355]
```
) -> Result<(), LocalApplyError<T::Error>> {
```
[21.22310]
[21.22355]
```
) -> Result<(), LocalApplyError<T::GraphError>> {
```
Replacement in libpijul/src/apply.rs at line 891 [22.944089]
B:BD[21.22475] → [21.22475:22516]
```
        if !is_alive(txn, channel, up) {
```
[21.22475]
[21.22516]
```
        if !is_alive(txn, channel, up)? {
```
Replacement in libpijul/src/apply.rs at line 908 [22.944089]
B:BD[21.22912] → [21.22912:22959]
```
fn repair_new_vertex_context_down<T: MutTxnT>(
```
[21.22912]
[21.22959]
```
fn repair_new_vertex_context_down<T: GraphMutTxnT>(
```
Replacement in libpijul/src/apply.rs at line 910 [22.944089]
B:BD[21.22976] → [21.22976:23006]
```
    channel: &mut Channel<T>,
```
[21.22976]
[21.23006]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/apply.rs at line 915 [22.944089]
B:BD[21.23118] → [21.23118:23163]
```
) -> Result<(), LocalApplyError<T::Error>> {
```
[21.23118]
[21.23163]
```
) -> Result<(), LocalApplyError<T::GraphError>> {
```
Replacement in libpijul/src/apply.rs at line 920 [22.944089]
B:BD[21.23294] → [21.23294:23334]
```
    for down in n.down_context.iter() {
```
[21.23294]
[21.23334]
```
    'outer: for down in n.down_context.iter() {
```
Replacement in libpijul/src/apply.rs at line 922 [22.944089]
B:BD[21.23418] → [21.23418:23444]
```
        if iter_adjacent(
```
[21.23418]
[21.23444]
```
        for e in iter_adjacent(
```

Replacement in libpijul/src/apply.rs at line 928 [22.944089]

B:BD[21.23582] → [21.23582:23671]

        )
        .any(|e| e.introduced_by != change_id)
        {
            continue;

[21.23582]

[21.23671]

        )? {
            let e = e?;
            if e.introduced_by != change_id {
                continue 'outer;
            }

Replacement in libpijul/src/apply.rs at line 948 [22.944089]
B:BD[21.24008] → [21.24008:24044]
```
fn repair_edge_context<T: MutTxnT>(
```
[21.24008]
[22.978666]
```
fn repair_edge_context<T: GraphMutTxnT>(
```
Replacement in libpijul/src/apply.rs at line 950 [22.944089]
B:BD[22.978683] → [22.978683:978713]
```
    channel: &mut Channel<T>,
```
[22.978683]
[22.978713]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/apply.rs at line 955 [22.944089]
B:BD[21.24076] → [21.24076:24121]
```
) -> Result<(), LocalApplyError<T::Error>> {
```
[21.24076]
[21.24121]
```
) -> Result<(), LocalApplyError<T::GraphError>> {
```
Replacement in libpijul/src/apply.rs at line 987 [22.944089]
B:BD[21.25019] → [21.25019:25066]
```
pub(crate) fn repair_cyclic_paths<T: MutTxnT>(
```
[21.25019]
[21.25066]
```
pub(crate) fn repair_cyclic_paths<T: GraphMutTxnT>(
```
Replacement in libpijul/src/apply.rs at line 989 [22.944089]
B:BD[21.25083] → [21.25083:25113]
```
    channel: &mut Channel<T>,
```
[21.25083]
[21.25113]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/apply.rs at line 991 [22.944089]
∅:D[21.25137] → [23.100107:100152]
B:BD[22.978783] → [23.100107:100152]
```
) -> Result<(), LocalApplyError<T::Error>> {
```
[21.25137]
[22.978816]
```
) -> Result<(), LocalApplyError<T::GraphError>> {
```

Replacement in libpijul/src/apply.rs at line 1002 [22.944089]

B:BD[21.25541] → [21.25541:25622]

            if let Some(ee) = iter_adjacent(txn, channel, file, f0, f1).next() {

[21.25541]

[21.25622]

            let mut iter = iter_adjacent(txn, channel, file, f0, f1)?;
            if let Some(ee) = iter.next() {
                let ee = ee?;

Replacement in libpijul/src/apply.rs at line 1017 [22.944089]
B:BD[22.979487] → [22.979487:979515]
```
fn repair_edge<T: MutTxnT>(
```
[22.979487]
[22.979515]
```
fn repair_edge<T: GraphMutTxnT>(
```
Replacement in libpijul/src/apply.rs at line 1019 [22.944089]
B:BD[22.979532] → [22.979532:979562]
```
    channel: &mut Channel<T>,
```
[22.979532]
[21.25827]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/apply.rs at line 1022 [22.944089]
B:BD[22.979642] → [23.100153:100198]
```
) -> Result<(), LocalApplyError<T::Error>> {
```
[22.979642]
[21.25855]
```
) -> Result<(), LocalApplyError<T::GraphError>> {
```

Replacement in libpijul/src/apply.rs at line 1044 [22.944089]

B:BD[21.26527] → [21.26527:26609]

        for parent in iter_adjacent(txn, channel, current, f, EdgeFlags::all()) {

[21.26527]

[21.26609]

        for parent in iter_adjacent(txn, channel, current, f, EdgeFlags::all())? {
            let parent = parent?;

Replacement in libpijul/src/apply.rs at line 1049 [22.944089]

B:BD[21.26780] → [21.26780:26820]

                let al = iter_adjacent(

[21.26780]

[21.26820]

                let al = if let Some(e) = iter_adjacent(

Replacement in libpijul/src/apply.rs at line 1055 [22.944089]
B:BD[21.26984] → [21.26984:27002]
```
                )
```
[21.26984]
[21.27002]
```
                )?
```

Replacement in libpijul/src/apply.rs at line 1057 [22.944089]

B:BD[21.27026] → [21.27026:27054]

                .is_some();

[21.27026]

[21.27054]

Replacement in libpijul/src/apply.rs at line 1084 [22.944089]

B:BD[21.27699] → [21.27699:27766]

                )
                .map_err(LocalApplyError::Txn)?;

[21.27699]

[21.27766]

)?;

Replacement in libpijul/src/apply.rs at line 1092 [22.944089]
B:BD[22.980815] → [22.980815:980838]
```
fn is_rooted<T: TxnT>(
```
[22.980815]
[22.980838]
```
fn is_rooted<T: GraphTxnT>(
```
Replacement in libpijul/src/apply.rs at line 1094 [22.944089]
B:BD[22.980851] → [22.980851:980877]
```
    channel: &Channel<T>,
```
[22.980851]
[22.980877]
```
    channel: &T::Graph,
```
Replacement in libpijul/src/apply.rs at line 1097 [22.944089]
B:BD[22.980926] → [23.100325:100372]
```
) -> Result<bool, LocalApplyError<T::Error>> {
```
[22.980926]
[21.27818]
```
) -> Result<bool, LocalApplyError<T::GraphError>> {
```

Replacement in libpijul/src/apply.rs at line 1100 [22.944089]

B:BD[21.27872] → [21.27872:27956]

    for e in iter_adjacent(txn, channel, v, EdgeFlags::empty(), EdgeFlags::all()) {

[21.27872]

[21.27956]

    for e in iter_adjacent(txn, channel, v, EdgeFlags::empty(), EdgeFlags::all())? {
        let e = e?;

Replacement in libpijul/src/apply.rs at line 1153 [22.944089]
B:BD[26.72508] → [26.72508:72520]
```
        ) {
```
[26.72508]
[22.981980]
```
        )? {
            let parent = parent?;
```

Replacement in libpijul/src/alive/retrieve.rs at line 6 [22.984582]

B:BD[22.984783] → [22.984783:984876]

pub fn retrieve<T: TxnT>(txn: &T, channel: &Channel<T>, pos0: Position<ChangeId>) -> Graph {

[22.984783]

[22.984935]

pub fn retrieve<T: GraphTxnT>(
    txn: &T,
    channel: &T::Graph,
    pos0: Position<ChangeId>,
) -> Result<Graph, TxnErr<T::GraphError>> {

Replacement in libpijul/src/alive/retrieve.rs at line 41 [22.984582]
B:BD[22.985958] → [22.985958:985970]
```
        ) {
```
[22.985958]
[22.985970]
```
        )? {
            let e = e?;
```

Replacement in libpijul/src/alive/retrieve.rs at line 45 [22.984582]

B:BD[22.986065] → [26.72658:72734]

                    if let Some(alive) = new_vertex(txn, channel, e.dest) {

[22.986065]

[26.72734]

                    if let Some(alive) = new_vertex(txn, channel, e.dest)? {

Replacement in libpijul/src/alive/retrieve.rs at line 67 [22.984582]
B:BD[22.986904] → [22.986904:986914]
```
    graph
```
[22.986904]
[22.986914]
```
    Ok(graph)
```
Replacement in libpijul/src/alive/retrieve.rs at line 70 [22.984582]
∅:D[42.2140] → [26.73099:73123]
B:BD[22.986971] → [26.73099:73123]
```
fn new_vertex<T: TxnT>(
```
[42.2140]
[26.73123]
```
fn new_vertex<T: GraphTxnT>(
```
Replacement in libpijul/src/alive/retrieve.rs at line 72 [22.984582]
B:BD[26.73136] → [26.73136:73162]
```
    channel: &Channel<T>,
```
[26.73136]
[26.73162]
```
    graph: &T::Graph,
```

Replacement in libpijul/src/alive/retrieve.rs at line 74 [22.984582]

B:BD[26.73191] → [26.73191:73293]

B:BD[26.73293] → [42.2141:2204]

) -> Option<AliveVertex> {
    let vertex = crate::pristine::find_block(txn, &channel, pos).unwrap();
    if !is_alive(txn, &channel, vertex) {
        return None;

[26.73191]

[42.2204]

) -> Result<Option<AliveVertex>, TxnErr<T::GraphError>> {
    let vertex = crate::pristine::find_block(txn, graph, pos).unwrap();
    if !is_alive(txn, graph, vertex)? {
        return Ok(None);
    }
    let mut flags = Flags::empty();
    for e in crate::pristine::iter_adjacent(
        txn,
        graph,
        vertex,
        EdgeFlags::PARENT | EdgeFlags::DELETED | EdgeFlags::BLOCK,
        EdgeFlags::all(),
    )? {
        if e?
            .flag
            .contains(EdgeFlags::PARENT | EdgeFlags::DELETED | EdgeFlags::BLOCK)
        {
            flags = Flags::ZOMBIE;
            break;
        }

Replacement in libpijul/src/alive/retrieve.rs at line 95 [22.984582]
∅:D[42.2210] → [26.73542:73565]
∅:D[62.2135] → [26.73542:73565]
B:BD[26.73542] → [26.73542:73565]
```
    Some(AliveVertex {
```
[42.2210]
[26.73565]
```
    Ok(Some(AliveVertex {
```

Replacement in libpijul/src/alive/retrieve.rs at line 97 [22.984582]

B:BD[26.73581] → [26.73581:73801]

B:BD[26.73801] → [39.7870:7889]

∅:D[39.7889] → [26.73823:73927]

B:BD[26.73823] → [26.73823:73927]

B:BD[26.73927] → [39.7890:7903]

∅:D[39.7903] → [22.987415:987496]

B:BD[22.987415] → [22.987415:987496]

        flags: if crate::pristine::iter_adjacent(
            txn,
            &channel,
            vertex,
            EdgeFlags::PARENT | EdgeFlags::DELETED | EdgeFlags::BLOCK,
            EdgeFlags::all(),
        )
        .any(|e| {
            e.flag
                .contains(EdgeFlags::PARENT | EdgeFlags::DELETED | EdgeFlags::BLOCK)
        }) {
            Flags::ZOMBIE
        } else {
            Flags::empty()
        },

[26.73581]

[22.987496]

        flags,

Replacement in libpijul/src/alive/retrieve.rs at line 103 [22.984582]
B:BD[22.987594] → [26.73974:73981]
```
    })
```
[22.987594]
[22.987600]
```
    }))
```
Replacement in libpijul/src/alive/retrieve.rs at line 106 [22.984582]
∅:D[42.2212] → [22.987657:987705]
B:BD[22.987657] → [22.987657:987705]
```
pub(crate) fn remove_forward_edges<T: MutTxnT>(
```
[42.2212]
[22.987705]
```
pub(crate) fn remove_forward_edges<T: GraphMutTxnT>(
```
Replacement in libpijul/src/alive/retrieve.rs at line 108 [22.984582]
B:BD[22.987722] → [22.987722:987752]
```
    channel: &mut Channel<T>,
```
[22.987722]
[22.987752]
```
    channel: &mut T::Graph,
```
Replacement in libpijul/src/alive/retrieve.rs at line 110 [22.984582]
B:BD[22.987781] → [23.100373:100401]
∅:D[23.100401] → [22.987814:987863]
B:BD[22.987814] → [22.987814:987863]
```
) -> Result<(), T::Error> {
    let mut graph = retrieve(txn, channel, pos);
```
[22.987781]
[22.987863]
```
) -> Result<(), TxnErr<T::GraphError>> {
    let mut graph = retrieve(txn, channel, pos)?;
```

Replacement in libpijul/src/alive/retrieve.rs at line 115 [22.984582]

B:BD[22.988012] → [22.988012:988093]

    graph.collect_forward_edges(txn, channel, &scc, &forward_scc, &mut forward);

[22.988012]

[22.988093]

    graph.collect_forward_edges(txn, channel, &scc, &forward_scc, &mut forward)?;

Replacement in libpijul/src/alive/retrieve.rs at line 117 [22.984582]

B:BD[22.988137] → [26.73982:74065]

        let dest = crate::pristine::find_block(txn, &channel, edge.dest).unwrap();

[22.988137]

[22.988202]

        let dest = crate::pristine::find_block(txn, channel, edge.dest).unwrap();

Replacement in libpijul/src/alive/output.rs at line 16 [22.988425]
∅:D[23.100436] → [22.988843:988905]
B:BD[22.988843] → [22.988843:988905]
```
fn output_conflict<T: TxnT, B: VertexBuffer, P: ChangeStore>(
```
[23.100436]
[22.988905]
```
fn output_conflict<T: ChannelTxnT, B: VertexBuffer, P: ChangeStore>(
```
Replacement in libpijul/src/alive/output.rs at line 24 [22.988425]
B:BD[22.989052] → [23.100437:100476]
```
) -> Result<(), FileError<P::Error>> {
```
[22.989052]
[22.989085]
```
) -> Result<(), FileError<P::Error, T::GraphError>> {
```

Replacement in libpijul/src/alive/output.rs at line 38 [22.988425]

B:BD[22.989641] → [22.989641:989723]

                    .map(|a| a.oldest_vertex(changes, txn, channel, graph, sccs))

[22.989641]

[22.989723]

                    .map(|a| a.oldest_vertex(changes, txn, channel, graph, sccs).unwrap())

Replacement in libpijul/src/alive/output.rs at line 44 [22.988425]

B:BD[22.989862] → [22.989862:989944]

                    .map(|b| b.oldest_vertex(changes, txn, channel, graph, sccs))

[22.989862]

[22.989944]

                    .map(|b| b.oldest_vertex(changes, txn, channel, graph, sccs).unwrap())

Replacement in libpijul/src/alive/output.rs at line 91 [22.988425]
B:BD[22.991509] → [22.991509:991556]
```
    fn oldest_vertex<T: TxnT, C: ChangeStore>(
```
[22.991509]
[22.991556]
```
    fn oldest_vertex<T: ChannelTxnT, C: ChangeStore>(
```
Replacement in libpijul/src/alive/output.rs at line 98 [22.988425]
B:BD[22.991696] → [22.991696:991711]
```
    ) -> u64 {
```
[22.991696]
[22.991711]
```
    ) -> Result<u64, TxnErr<T::GraphError>> {
```

Replacement in libpijul/src/alive/output.rs at line 100 [22.988425]

B:BD[22.991733] → [22.991733:991839]

            PathElement::Scc { ref scc } => sccs[*scc]
                .iter()
                .map(|x| {

[22.991733]

[22.991839]

            PathElement::Scc { ref scc } => {
                let mut min: Option<u64> = None;
                for x in sccs[*scc].iter() {

Replacement in libpijul/src/alive/output.rs at line 104 [22.988425]

B:BD[22.991876] → [22.991876:991967]

                        txn.get_changeset(&channel.changes, graph[*x].vertex.change, None)

[22.991876]

[22.991967]

                        txn.get_changeset(&channel.changes, graph[*x].vertex.change, None)?

Replacement in libpijul/src/alive/output.rs at line 106 [22.988425]

B:BD[22.991989] → [22.991989:992015]

[22.991989]

[22.992015]

                        if let Some(ref mut m) = min {
                            *m = (*m).min(t)
                        } else {
                            min = Some(t)
                        }

Replacement in libpijul/src/alive/output.rs at line 114 [22.988425]

B:BD[22.992189] → [22.992189:992278]

                            graph.debug(changes, txn, channel, false, true, f).unwrap();

[22.992189]

[22.992278]

                            graph
                                .debug(changes, txn, &channel.graph, false, true, f)
                                .unwrap();

Replacement in libpijul/src/alive/output.rs at line 120 [22.988425]

B:BD[22.992406] → [22.992406:992862]

                })
                .min()
                .unwrap(),
            PathElement::Conflict { ref sides } => sides
                .iter()
                .map(|x| {
                    x.path
                        .iter()
                        .map(|x| x.oldest_vertex(changes, txn, channel, graph, sccs))
                        .min()
                        .unwrap()
                })
                .min()
                .unwrap(),

[22.992406]

[22.992862]

                }
                Ok(min.unwrap())
            }
            PathElement::Conflict { ref sides } => {
                let mut min: Option<u64> = None;
                for x in sides.iter() {
                    for y in x.path.iter() {
                        let t = y.oldest_vertex(changes, txn, channel, graph, sccs)?;
                        if let Some(ref mut m) = min {
                            *m = (*m).min(t)
                        } else {
                            min = Some(t)
                        }
                    }
                }
                Ok(min.unwrap())
            }

Replacement in libpijul/src/alive/output.rs at line 141 [22.988425]
∅:D[23.100484] → [22.992935:992992]
B:BD[22.992935] → [22.992935:992992]
```
fn output_scc<T: TxnT, B: VertexBuffer, P: ChangeStore>(
```
[23.100484]
[22.992992]
```
fn output_scc<T: GraphTxnT, B: VertexBuffer, P: ChangeStore>(
```
Replacement in libpijul/src/alive/output.rs at line 147 [22.988425]
B:BD[22.993081] → [23.100485:100524]
```
) -> Result<(), FileError<P::Error>> {
```
[22.993081]
[22.993114]
```
) -> Result<(), FileError<P::Error, T::GraphError>> {
```

Replacement in libpijul/src/alive/output.rs at line 163 [22.988425]

B:BD[23.100647] → [23.100647:100715]

                .get_contents(|p| txn.get_external(p), vertex, buf)

[23.100647]

[23.100715]

                .get_contents(|p| txn.get_external(p).unwrap(), vertex, buf)

Replacement in libpijul/src/alive/output.rs at line 186 [22.988425]
∅:D[23.100890] → [22.994281:994344]
B:BD[22.994281] → [22.994281:994344]
```
pub fn output_graph<T: TxnT, B: VertexBuffer, P: ChangeStore>(
```
[23.100890]
[22.994344]
```
pub fn output_graph<T: ChannelTxnT, B: VertexBuffer, P: ChangeStore>(
```
Replacement in libpijul/src/alive/output.rs at line 193 [22.988425]
B:BD[22.994494] → [23.100891:100945]
```
) -> Result<(), crate::output::FileError<P::Error>> {
```
[22.994494]
[22.994527]
```
) -> Result<(), crate::output::FileError<P::Error, T::GraphError>> {
```

Replacement in libpijul/src/alive/output.rs at line 200 [22.988425]

B:BD[22.994757] → [22.994757:994833]

    graph.collect_forward_edges(txn, channel, &scc, &forward_scc, forward);

[22.994757]

[22.994833]

    graph.collect_forward_edges(txn, &channel.graph, &scc, &forward_scc, forward)?;

Replacement in libpijul/src/alive/dfs.rs at line 359 [22.1000429]
B:BD[22.1013140] → [22.1013140:1013190]
```
    pub(super) fn collect_forward_edges<T: TxnT>(
```
[22.1013140]
[22.1013190]
```
    pub(super) fn collect_forward_edges<T: GraphTxnT>(
```
Replacement in libpijul/src/alive/dfs.rs at line 362 [22.1000429]
B:BD[22.1013222] → [22.1013222:1013252]
```
        channel: &Channel<T>,
```
[22.1013222]
[22.1013252]
```
        channel: &T::Graph,
```
Replacement in libpijul/src/alive/dfs.rs at line 366 [22.1000429]
B:BD[22.1013385] → [22.1013385:1013393]
```
    ) {
```
[22.1013385]
[22.1013393]
```
    ) -> Result<(), TxnErr<T::GraphError>> {
```
Replacement in libpijul/src/alive/dfs.rs at line 385 [22.1000429]
B:BD[22.1014294] → [22.1014294:1014324]
```
                            )
```
[22.1014294]
[22.1014324]
```
                            )?
```
Insertion in libpijul/src/alive/dfs.rs at line 393 [22.1000429]
[22.1014511]
[22.1014511]
```
        Ok(())
```
Replacement in libpijul/src/alive/debug.rs at line 3 [22.1014531]
B:BD[22.1014644] → [22.1014644:1014700]
```
use crate::pristine::{Base32, Channel, Position, TxnT};
```
[22.1014644]
[22.1014700]
```
use crate::pristine::{Base32, GraphTxnT, Position};
```
Replacement in libpijul/src/alive/debug.rs at line 10 [22.1014531]
B:BD[22.1014871] → [22.1014871:1014924]
```
    pub fn debug<W: Write, T: TxnT, P: ChangeStore>(
```
[22.1014871]
[22.1014924]
```
    pub fn debug<W: Write, T: GraphTxnT, P: ChangeStore>(
```
Replacement in libpijul/src/alive/debug.rs at line 14 [22.1014531]
B:BD[22.1014977] → [22.1014977:1015007]
```
        channel: &Channel<T>,
```
[22.1014977]
[22.1015007]
```
        channel: &T::Graph,
```

Replacement in libpijul/src/alive/debug.rs at line 36 [22.1014531]

B:BD[23.101031] → [23.101031:101109]

                .get_contents(|h| txn.get_external(h), line.vertex, &mut buf)

[23.101031]

[23.101109]

                .get_contents(|h| txn.get_external(h).unwrap(), line.vertex, &mut buf)

Replacement in libpijul/src/alive/debug.rs at line 63 [22.1014531]

B:BD[22.1016628] → [26.74253:74351]

∅:D[26.74351] → [22.1016729:1016807]

B:BD[22.1016729] → [22.1016729:1016807]

                for (_, v) in crate::pristine::iter_graph(txn, &channel.graph, line.vertex, None)
                    .take_while(|&(k, _)| k == line.vertex)
                {

[22.1016628]

[22.1016807]

                for x in crate::pristine::iter_graph(txn, &channel, line.vertex, None).unwrap() {
                    let (k, v) = x.unwrap();
                    if k != line.vertex {
                        break;
                    }

Replacement in libpijul/Cargo.toml at line 4 [22.1020742]
B:BD[22.1020894] → [19.184:211]
```
version = "1.0.0-alpha.22"
```
[22.1020894]
[22.1020920]
```
version = "1.0.0-alpha.23"
```

Replacement in libpijul/Cargo.toml at line 86 [22.1020742]

B:BD[22.1022736] → [38.2992:3054]

ondisk-repos = [ "mmap", "zstd", "ignore", "canonical-path" ]

[22.1022736]

[22.1022780]

ondisk-repos = [ "mmap", "zstd", "ignore", "canonical-path", "lru-cache", "tempfile" ]

Replacement in libpijul/Cargo.toml at line 95 [22.1020742]
B:BD[22.1022980] → [19.212:233]
```
sanakirja = "0.14.5"
```
[22.1022980]
[22.1023001]
```
sanakirja = "0.15.2"
```
Replacement in libpijul/Cargo.toml at line 105 [22.1020742]
B:BD[22.1023195] → [24.204:227]
```
pijul-macros = "0.2.0"
```
[22.1023195]
[22.1023218]
```
pijul-macros = "0.3.0"
```
Deletion in libpijul/Cargo.toml at line 108 [22.1020742]
B:BD[22.1023256] → [22.1023256:1023274]
```
lru-cache = "0.1"
```
Deletion in libpijul/Cargo.toml at line 109 [22.1020742]
B:BD[22.1023288] → [22.1023288:1023305]
```
tempfile = "3.1"
```

Insertion in libpijul/Cargo.toml at line 119 [22.1020742]

[38.3109]

[22.1023703]

lru-cache = { version = "0.1", optional = true }
tempfile = { version = "3.1", optional = true }

Replacement in Cargo.nix at line 85 [68.12]
B:BD[68.2998] → [68.2998:3026]
```
        version = "0.14.0";
```
[68.2998]
[68.3026]
```
        version = "0.14.1";
```

Replacement in Cargo.nix at line 87 [68.12]

B:BD[68.3052] → [68.3052:3125]

        sha256 = "08x42676mp3wa4amhgnlwlsjxsyarfgr2sc283srppbqkvb2j2bw";

[68.3052]

[68.3125]

        sha256 = "1xs5bsi40zpyxbbylyaysya5h36ykcbg91i82415sxw5wk7q4px5";

Replacement in Cargo.nix at line 146 [68.12]
B:BD[68.5657] → [19.234:262]
```
        version = "1.0.36";
```
[68.5657]
[68.5685]
```
        version = "1.0.37";
```

Replacement in Cargo.nix at line 148 [68.12]

B:BD[68.5711] → [19.263:336]

        sha256 = "0yclpf28nrck31p7zwwckqjhvdl2fdlg4xmb3cclfgmilwjk5038";

[68.5711]

[68.5784]

        sha256 = "11kaqp25lchr2ckyc46zm6blzndnw0w2w8qv0sp8z4xcxqgw2rzf";

Replacement in Cargo.nix at line 703 [68.12]
B:BD[69.330] → [69.330:358]
```
        version = "0.13.0";
```
[69.330]
[69.358]
```
        version = "0.14.0";
```

Replacement in Cargo.nix at line 705 [68.12]

B:BD[69.384] → [69.384:457]

        sha256 = "022ai0jbbawngrx396qppwgzk4pk3v2fdwckzamvz6h154jsn2m5";

[69.384]

[68.28900]

        sha256 = "1ajnr0rga4vya0fza12ighf3ffkm86w1rv8p5wf443s8nd30kj3w";

Deletion in Cargo.nix at line 744 [68.12]

B:BD[69.1482] → [69.1482:1669]

          }
          {
            name = "winapi-util";
            packageId = "winapi-util";
            optional = true;
            target = { target, features }: target."windows";

Replacement in Cargo.nix at line 748 [68.12]

B:BD[69.1743] → [69.1743:1826]

          "default" = [ "unicode-width" "ansi-parsing" "windows-console-colors" ];

[69.1743]

[69.1826]

          "default" = [ "unicode-width" "ansi-parsing" ];

Replacement in Cargo.nix at line 751 [68.12]

B:BD[69.1908] → [69.1908:2035]

        resolvedDefaultFeatures = [ "ansi-parsing" "default" "regex" "unicode-width" "winapi-util" "windows-console-colors" ];

[69.1908]

[26.75063]

        resolvedDefaultFeatures = [ "ansi-parsing" "default" "regex" "unicode-width" ];

Replacement in Cargo.nix at line 1792 [68.12]
B:BD[68.59751] → [19.586:619]
```
      "getrandom 0.1.15" = rec {
```
[68.59751]
[68.59777]
```
      "getrandom 0.1.16" = rec {
```
Replacement in Cargo.nix at line 1794 [68.12]
B:BD[68.59810] → [68.59810:59838]
```
        version = "0.1.15";
```
[68.59810]
[68.59838]
```
        version = "0.1.16";
```

Replacement in Cargo.nix at line 1796 [68.12]

B:BD[68.59864] → [68.59864:59937]

        sha256 = "1rj7psnlrnmsgyj6x2ag4c6367laq4g8kfd6pzamac99xk07nn7w";

[68.59864]

[68.59937]

        sha256 = "1kjzmz60qx9mn615ks1akjbf36n3lkv27zfwbcam0fzmj56wphwg";

Replacement in Cargo.nix at line 1803 [68.12]

B:BD[68.60074] → [68.60074:60115]

            packageId = "cfg-if 0.1.10";

[68.60074]

[68.60115]

            packageId = "cfg-if 1.0.0";

Insertion in Cargo.nix at line 1820 [68.12]

[68.60634]

[19.620]

          "wasm-bindgen" = [ "bindgen" "js-sys" ];

Replacement in Cargo.nix at line 1875 [68.12]
B:BD[68.61459] → [19.1570:1599]
```
        version = "0.13.14";
```
[68.61459]
[68.61488]
```
        version = "0.13.15";
```

Replacement in Cargo.nix at line 1877 [68.12]

B:BD[68.61514] → [19.1600:1673]

        sha256 = "0q420j5lw7qchp5f6pgq938dkfi7pfllyqdd8j1yaxkmqyfdjv8q";

[68.61514]

[68.61587]

        sha256 = "0na3vsa44nn1sr6pzscn93w69wbmdih277mm2p3f6kcavb4ngwj4";

Replacement in Cargo.nix at line 2551 [68.12]
B:BD[68.79414] → [68.79414:79441]
```
        version = "0.4.6";
```
[68.79414]
[68.79441]
```
        version = "0.4.7";
```

Replacement in Cargo.nix at line 2553 [68.12]

B:BD[68.79467] → [68.79467:79540]

        sha256 = "1rnpb7rr8df76gnlk07b9086cn7fc0dxxy1ghh00q6nip7bklvyw";

[68.79467]

[68.79540]

        sha256 = "0di7fggbknwfjcw8cgzm1dnm3ik32l2m1f7nmyh8ipmh45h069fx";

Replacement in Cargo.nix at line 2647 [68.12]
B:BD[68.82507] → [19.2211:2246]
```
        version = "0.12.16+1.1.0";
```
[68.82507]
[68.82542]
```
        version = "0.12.17+1.1.0";
```

Replacement in Cargo.nix at line 2649 [68.12]

B:BD[68.82568] → [19.2247:2320]

        sha256 = "083hr4d1if61pb997myp57hfh0idv26bx5ai2nc5m5zf67wv54cz";

[68.82568]

[68.82641]

        sha256 = "0hc89v7kp2b3rbc64cxq024shd85m8vqcs14i3gjclblr9jxzszl";

Replacement in Cargo.nix at line 2699 [68.12]
B:BD[68.84748] → [19.2321:2357]
```
        version = "1.0.0-alpha.22";
```
[68.84748]
[68.84783]
```
        version = "1.0.0-alpha.23";
```
Insertion in Cargo.nix at line 2766 [68.12]
[68.86369]
[68.86369]
```
            optional = true;
```
Insertion in Cargo.nix at line 2801 [68.12]
[68.87143]
[68.87143]
```
            optional = true;
```

Replacement in Cargo.nix at line 2837 [68.12]

B:BD[68.87922] → [70.547:619]

          "ondisk-repos" = [ "mmap" "zstd" "ignore" "canonical-path" ];

[68.87922]

[68.87977]

          "ondisk-repos" = [ "mmap" "zstd" "ignore" "canonical-path" "lru-cache" "tempfile" ];

Replacement in Cargo.nix at line 2842 [68.12]

B:BD[68.88110] → [70.620:803]

        resolvedDefaultFeatures = [ "canonical-path" "default" "dump" "flate2" "ignore" "mmap" "ondisk-repos" "regex" "tar" "tarball" "text-changes" "tokio" "zstd" "zstd-seekable" ];

[68.88110]

[68.88276]

        resolvedDefaultFeatures = [ "canonical-path" "default" "dump" "flate2" "ignore" "lru-cache" "mmap" "ondisk-repos" "regex" "tar" "tarball" "tempfile" "text-changes" "tokio" "zstd" "zstd-seekable" ];

Replacement in Cargo.nix at line 3272 [68.12]
B:BD[68.100155] → [68.100155:100182]
```
        version = "0.2.6";
```
[68.100155]
[68.100182]
```
        version = "0.2.7";
```

Replacement in Cargo.nix at line 3274 [68.12]

B:BD[68.100208] → [68.100208:100281]

        sha256 = "0grsinsgq1pd70c6k9mif7wambwq2jxh8jhvdgwf9i7dnlwpkk3g";

[68.100208]

[68.100281]

        sha256 = "1m6v16xl8h4pm32pw6yhrvgwznf60bqhj2qhb1yrb8wd3hp6pndq";

Insertion in Cargo.nix at line 3328 [68.12]

[68.102409]

          }
        ];
        devDependencies = [
          {
            name = "tempfile";
            packageId = "tempfile";

Insertion in Cargo.nix at line 3337 [68.12]
[68.102453]
[68.102453]
```
          "alpn" = [ "security-framework/alpn" ];
```

Deletion in Cargo.nix at line 3873 [68.12]

B:BD[68.117476] → [68.117476:117569]

          }
          {
            name = "thiserror";
            packageId = "thiserror";

Replacement in Cargo.nix at line 3908 [68.12]
B:BD[68.118308] → [70.1303:1330]
```
        version = "0.2.0";
```
[68.118308]
[68.118335]
```
        version = "0.3.0";
```

Replacement in Cargo.nix at line 4215 [68.12]

B:BD[68.126837] → [19.3372:3416]

            packageId = "getrandom 0.1.15";

[68.126837]

[68.126874]

            packageId = "getrandom 0.1.16";

Replacement in Cargo.nix at line 4381 [68.12]

B:BD[68.129574] → [19.6248:6292]

            packageId = "getrandom 0.1.15";

[68.129574]

[19.6292]

            packageId = "getrandom 0.1.16";

Replacement in Cargo.nix at line 4468 [68.12]

B:BD[68.130971] → [19.7444:7488]

            packageId = "getrandom 0.1.15";

[68.130971]

[68.131008]

            packageId = "getrandom 0.1.16";

Replacement in Cargo.nix at line 4857 [68.12]
B:BD[68.144463] → [19.7593:7621]
```
        version = "0.14.5";
```
[68.144463]
[68.144491]
```
        version = "0.15.2";
```

Replacement in Cargo.nix at line 4859 [68.12]

B:BD[68.144517] → [19.7622:7695]

        sha256 = "1231wkv5dv08k9sv85isaa8ra8j0nd8jjxirlzz7196fws5v4zhf";

[68.144517]

[68.144590]

        sha256 = "0bsym4q8zm0q7zk5jj5ik02ip3yjr3p5y27mrsg1p03jazz7jw6y";

Insertion in Cargo.nix at line 4866 [68.12]

[68.144721]

            name = "crc32fast";
            packageId = "crc32fast";
            optional = true;
          }
          {

Replacement in Cargo.nix at line 4898 [68.12]

B:BD[68.145311] → [68.145311:145344]

          "mmap" = [ "memmap" ];

[68.145311]

[68.145344]

          "crc32" = [ "crc32fast" ];
          "mmap" = [ "memmap" "crc32" ];

Replacement in Cargo.nix at line 4901 [68.12]

B:BD[68.145355] → [68.145355:145427]

        resolvedDefaultFeatures = [ "default" "git2" "memmap" "mmap" ];

[68.145355]

[68.145427]

        resolvedDefaultFeatures = [ "crc32" "crc32fast" "default" "git2" "memmap" "mmap" ];

Replacement in Cargo.nix at line 5066 [68.12]
B:BD[68.150408] → [19.7943:7971]
```
        version = "1.0.60";
```
[68.150408]
[68.150436]
```
        version = "1.0.61";
```

Replacement in Cargo.nix at line 5068 [68.12]

B:BD[68.150462] → [19.7972:8045]

        sha256 = "0yapc7xxk8dx12691yj0l13008rgvknmc6krvk8jwj7y4x6yh00m";

[68.150462]

[68.150535]

        sha256 = "0nijvxvgcncvd1wbn73zx7q14bdxah0gf2789qd8kdjpa1cv5kjg";

Replacement in Cargo.nix at line 5202 [68.12]
B:BD[68.154961] → [19.8471:8499]
```
        version = "1.0.55";
```
[68.154961]
[68.154989]
```
        version = "1.0.56";
```

Replacement in Cargo.nix at line 5204 [68.12]

B:BD[68.155015] → [19.8500:8573]

        sha256 = "0ypk6j1p1akpd016rh0ksl4rpic7zqbip3k2rjf022fxvl8sfwd5";

[68.155015]

[68.155088]

        sha256 = "0wlvjgxhqvcp36zg20q4jzx5khfrk2vhal7fxs3d2w21x7fjv059";

Replacement in Cargo.nix at line 5369 [68.12]
B:BD[68.159661] → [68.159661:159689]
```
        version = "1.0.22";
```
[68.159661]
[68.159689]
```
        version = "1.0.23";
```

Replacement in Cargo.nix at line 5371 [68.12]

B:BD[68.159715] → [68.159715:159788]

        sha256 = "0gp5wp7izpv9rdvq035ajbxcl3g0vck61pg9y6mfsvk1hi5y76hf";

[68.159715]

[68.159788]

        sha256 = "0imiv97kdlba0r0ld6mlizfmw5rpmfzhvk7xw8l8k35zd9n63k3n";

Replacement in Cargo.nix at line 5385 [68.12]
B:BD[68.160090] → [68.160090:160118]
```
        version = "1.0.22";
```
[68.160090]
[68.160118]
```
        version = "1.0.23";
```

Replacement in Cargo.nix at line 5387 [68.12]

B:BD[68.160144] → [68.160144:160217]

        sha256 = "0mnx51374c69l1w7gh98prn2wzm2yvmlll4ms567a42vx0ihz8lv";

[68.160144]

[68.160217]

        sha256 = "1law4wqpc36hxs4vcgc1pjjniy4l6xn7kwvf0k886xf2mqn3mrwv";

Replacement in Cargo.nix at line 5558 [68.12]

B:BD[70.2537] → [19.8717:8757]

            packageId = "whoami 1.0.1";

[70.2537]

[70.2577]

            packageId = "whoami 1.0.3";

Replacement in Cargo.nix at line 7033 [68.12]
B:BD[70.3095] → [19.10454:10483]
```
      "whoami 1.0.1" = rec {
```
[70.3095]
[70.3124]
```
      "whoami 1.0.3" = rec {
```
Replacement in Cargo.nix at line 7035 [68.12]
B:BD[70.3154] → [19.10484:10511]
```
        version = "1.0.1";
```
[70.3154]
[70.3181]
```
        version = "1.0.3";
```

Replacement in Cargo.nix at line 7037 [68.12]

B:BD[70.3207] → [19.10512:10585]

        sha256 = "0d90722ay0dlbgakxghmx5wpiibsqgcjb5wf382mgiplzbkram73";

[70.3207]

[70.3280]

        sha256 = "0dmlxqq6758wysx46zr64b4q9g72d0ax9f4hlpb86qgk8vhv55fm";

Replacement in Cargo.lock at line 5 [22.1030385]
B:BD[22.1030508] → [22.1030508:1030527]
```
version = "0.14.0"
```
[22.1030508]
[22.1030527]
```
version = "0.14.1"
```

Replacement in Cargo.lock at line 7 [22.1030385]

B:BD[22.1030592] → [22.1030592:1030670]

checksum = "7c0929d69e78dd9bf5408269919fcbcaeb2e35e5d43e5815517cdc6a8e11a423"

[22.1030592]

[22.1030670]

checksum = "a55f82cfe485775d02112886f4169bde0c5894d75e79ead7eafe7e40a25e45f7"

Replacement in Cargo.lock at line 29 [22.1030385]
B:BD[22.1031374] → [19.10688:10707]
```
version = "1.0.36"
```
[22.1031374]
[22.1031393]
```
version = "1.0.37"
```

Replacement in Cargo.lock at line 31 [22.1030385]

B:BD[22.1031458] → [19.10708:10786]

checksum = "68803225a7b13e47191bab76f2687382b60d259e8cf37f6e1893658b84bb9479"

[22.1031458]

[22.1031536]

checksum = "ee67c11feeac938fae061b232e38e0b6d94f97a9df10e6271319325ac4c56a86"

Replacement in Cargo.lock at line 232 [22.1030385]
B:BD[29.4483] → [29.4483:4502]
```
version = "0.13.0"
```
[29.4483]
[29.4502]
```
version = "0.14.0"
```

Replacement in Cargo.lock at line 234 [22.1030385]

B:BD[29.4567] → [29.4567:4645]

checksum = "a50aab2529019abfabfa93f1e6c41ef392f91fbf179b347a7e96abb524884a08"

[29.4567]

[29.4645]

checksum = "7cc80946b3480f421c2f17ed1cb841753a371c7c5104f51d507e13f532c856aa"

Deletion in Cargo.lock at line 243 [22.1030385]
B:BD[29.4769] → [29.4769:4785]
```
 "winapi-util",
```
Replacement in Cargo.lock at line 637 [22.1030385]
B:BD[22.1047515] → [22.1047515:1047534]
```
version = "0.1.15"
```
[22.1047515]
[22.1047534]
```
version = "0.1.16"
```

Replacement in Cargo.lock at line 639 [22.1030385]

B:BD[22.1047599] → [22.1047599:1047677]

checksum = "fc587bc0ec293155d5bfa6b9891ec18a1e330c234f896ea47fbada4cadbe47e6"

[22.1047599]

[71.126]

checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"

Replacement in Cargo.lock at line 641 [22.1030385]
B:BD[71.143] → [71.143:161]
```
 "cfg-if 0.1.10",
```
[71.143]
[71.161]
```
 "cfg-if 1.0.0",
```
Replacement in Cargo.lock at line 665 [22.1030385]
B:BD[22.1047978] → [19.10984:11004]
```
version = "0.13.14"
```
[22.1047978]
[22.1047998]
```
version = "0.13.15"
```

Replacement in Cargo.lock at line 667 [22.1030385]

B:BD[22.1048063] → [19.11005:11083]

checksum = "186dd99cc77576e58344ad614fa9bb27bad9d048f85de3ca850c1f4e8b048260"

[22.1048063]

[22.1048141]

checksum = "44f267c9da8a4de3c615b59e23606c75f164f84896e97f4dd6c15a4294de4359"

Replacement in Cargo.lock at line 903 [22.1030385]
B:BD[22.1053474] → [22.1053474:1053492]
```
version = "0.4.6"
```
[22.1053474]
[22.1053492]
```
version = "0.4.7"
```

Replacement in Cargo.lock at line 905 [22.1030385]

B:BD[22.1053557] → [22.1053557:1053635]

checksum = "dc6f3ad7b9d11a0c00842ff8de1b60ee58661048eb8049ed33c73594f359d7e6"

[22.1053557]

[22.1053635]

checksum = "dd25036021b0de88a0aff6b850051563c6516d0bf53f8638938edbb9de732736"

Replacement in Cargo.lock at line 949 [22.1030385]
B:BD[22.1054943] → [19.11576:11602]
```
version = "0.12.16+1.1.0"
```
[22.1054943]
[22.1054969]
```
version = "0.12.17+1.1.0"
```

Replacement in Cargo.lock at line 951 [22.1030385]

B:BD[22.1055034] → [19.11603:11681]

checksum = "9f91b2f931ee975a98155195be8cd82d02e8e029d7d793d2bac1b8181ac97020"

[22.1055034]

[22.1055112]

checksum = "f4ebdf65ca745126df8824688637aa0535a88900b83362d8ca63893bcf4e8841"

Replacement in Cargo.lock at line 963 [22.1030385]
B:BD[72.560] → [19.11682:11709]
```
version = "1.0.0-alpha.22"
```
[72.560]
[72.729]
```
version = "1.0.0-alpha.23"
```
Replacement in Cargo.lock at line 1157 [22.1030385]
B:BD[22.1059712] → [22.1059712:1059730]
```
version = "0.2.6"
```
[22.1059712]
[22.1059730]
```
version = "0.2.7"
```

Replacement in Cargo.lock at line 1159 [22.1030385]

B:BD[22.1059795] → [22.1059795:1059873]

checksum = "6fcc7939b5edc4e4f86b1b4a04bb1498afaaf871b1a6691838ed06fcb48d3a3f"

[22.1059795]

[22.1059873]

checksum = "b8d96b2e1c8da3957d58100b09f102c6d9cfdfced01b7ec5a8974044bb09dbd4"

Replacement in Cargo.lock at line 1333 [22.1030385]
B:BD[22.1064071] → [19.12339:12366]
```
version = "1.0.0-alpha.26"
```
[22.1064071]
[22.1064097]
```
version = "1.0.0-alpha.27"
```
Deletion in Cargo.lock at line 1364 [22.1030385]
B:BD[22.1064464] → [22.1064464:1064478]
```
 "thiserror",
```
Replacement in Cargo.lock at line 1374 [22.1030385]
B:BD[22.1064574] → [24.340:358]
```
version = "0.2.0"
```
[22.1064574]
[22.1064592]
```
version = "0.3.0"
```
Replacement in Cargo.lock at line 1512 [22.1030385]
B:BD[22.1068267] → [71.492:513]
```
 "getrandom 0.1.15",
```
[22.1068267]
[22.1068281]
```
 "getrandom 0.1.16",
```
Replacement in Cargo.lock at line 1557 [22.1030385]
B:BD[22.1068787] → [71.1121:1142]
```
 "getrandom 0.1.15",
```
[22.1068787]
[22.1068801]
```
 "getrandom 0.1.16",
```
Replacement in Cargo.lock at line 1599 [22.1030385]
B:BD[22.1069437] → [71.1627:1648]
```
 "getrandom 0.1.15",
```
[22.1069437]
[22.1069451]
```
 "getrandom 0.1.16",
```
Replacement in Cargo.lock at line 1711 [22.1030385]
B:BD[22.1072132] → [19.12565:12584]
```
version = "0.14.5"
```
[22.1072132]
[22.1072151]
```
version = "0.15.2"
```

Replacement in Cargo.lock at line 1713 [22.1030385]

B:BD[22.1072216] → [19.12585:12663]

checksum = "0e7eb28be6cea470fea739762951b340229591523a16b4759a08ec56f6e46188"

[22.1072216]

[22.1072294]

checksum = "de7079fe5772801b9ecef5085feec8d28f1b0598b14859e63f18d48f30a95e2f"

Insertion in Cargo.lock at line 1715 [22.1030385]
[22.1072311]
[22.1072311]
```
 "crc32fast",
```
Replacement in Cargo.lock at line 1785 [22.1030385]
B:BD[22.1073896] → [19.12864:12883]
```
version = "1.0.60"
```
[22.1073896]
[22.1073915]
```
version = "1.0.61"
```

Replacement in Cargo.lock at line 1787 [22.1030385]

B:BD[22.1073980] → [19.12884:12962]

checksum = "1500e84d27fe482ed1dc791a56eddc2f230046a040fa908c08bda1d9fb615779"

[22.1073980]

[22.1074058]

checksum = "4fceb2595057b6891a4ee808f70054bd2d12f0e97f1cbb78689b59f676df325a"

Replacement in Cargo.lock at line 1843 [22.1030385]
B:BD[22.1075798] → [19.13258:13277]
```
version = "1.0.55"
```
[22.1075798]
[22.1075817]
```
version = "1.0.56"
```

Replacement in Cargo.lock at line 1845 [22.1030385]

B:BD[22.1075882] → [19.13278:13356]

checksum = "a571a711dddd09019ccc628e1b17fe87c59b09d513c06c026877aa708334f37a"

[22.1075882]

[22.1075960]

checksum = "a9802ddde94170d186eeee5005b798d9c159fa970403f1be19976d0cfb939b72"

Replacement in Cargo.lock at line 1908 [22.1030385]
B:BD[22.1077299] → [22.1077299:1077318]
```
version = "1.0.22"
```
[22.1077299]
[22.1077318]
```
version = "1.0.23"
```

Replacement in Cargo.lock at line 1910 [22.1030385]

B:BD[22.1077383] → [22.1077383:1077461]

checksum = "0e9ae34b84616eedaaf1e9dd6026dbe00dcafa92aa0c8077cb69df1fcfe5e53e"

[22.1077383]

[22.1077461]

checksum = "76cc616c6abf8c8928e2fdcc0dbfab37175edd8fb49a4641066ad1364fdab146"

Replacement in Cargo.lock at line 1917 [22.1030385]
B:BD[22.1077536] → [22.1077536:1077555]
```
version = "1.0.22"
```
[22.1077536]
[22.1077555]
```
version = "1.0.23"
```

Replacement in Cargo.lock at line 1919 [22.1030385]

B:BD[22.1077620] → [22.1077620:1077698]

checksum = "9ba20f23e85b10754cd195504aebf6a27e2e6cbe28c17778a0c930724628dd56"

[22.1077620]

[22.1077698]

checksum = "9be73a2caec27583d0046ef3796c3794f868a5bc813db689eed00c7631275cd1"

Replacement in Cargo.lock at line 1978 [22.1030385]
B:BD[22.1078575] → [19.13457:13474]
```
 "whoami 1.0.1",
```
[22.1078575]
[22.1078575]
```
 "whoami 1.0.3",
```
Replacement in Cargo.lock at line 2371 [22.1030385]
B:BD[73.893] → [19.14500:14518]
```
version = "1.0.1"
```
[73.893]
[73.911]
```
version = "1.0.3"
```

Replacement in Cargo.lock at line 2373 [22.1030385]

B:BD[73.976] → [19.14519:14597]

checksum = "e35495e7faf4c657051a8e9725d9c37ac57879e915be3ed55bb401af84382035"

[73.976]

[73.1054]

checksum = "d595b2e146f36183d6a590b8d41568e2bc84c922267f43baf61c956330eeb436"

Upgrading to Sanakirja 0.15 + version bump

Dependencies

In channels

Change contents

Deletion in pijul-macros/src/lib.rs at line 36 [22.445]

Insertion in pijul-macros/src/lib.rs at line 52 [22.445]

Replacement in pijul-macros/src/lib.rs at line 69 [22.445]

Replacement in pijul-macros/src/lib.rs at line 76 [22.445]

Replacement in pijul-macros/src/lib.rs at line 83 [22.445]

Insertion in pijul-macros/src/lib.rs at line 103 [22.445]

Replacement in pijul-macros/src/lib.rs at line 111 [22.445]

Replacement in pijul-macros/src/lib.rs at line 113 [22.445]

Insertion in pijul-macros/src/lib.rs at line 133 [22.445]

Replacement in pijul-macros/src/lib.rs at line 141 [22.445]

Insertion in pijul-macros/src/lib.rs at line 157 [22.445]

Replacement in pijul-macros/src/lib.rs at line 165 [22.445]

Insertion in pijul-macros/src/lib.rs at line 234 [22.445]

Replacement in pijul-macros/src/lib.rs at line 244 [22.445]

Replacement in pijul-macros/src/lib.rs at line 248 [22.445]

Deletion in pijul-macros/src/lib.rs at line 255 [22.445]

Deletion in pijul-macros/src/lib.rs at line 256 [22.445]

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

Replacement in pijul-macros/src/lib.rs at line 263 [22.445]

Deletion in pijul-macros/src/lib.rs at line 268 [22.445]

Replacement in pijul-macros/src/lib.rs at line 272 [22.445]

Deletion in pijul-macros/src/lib.rs at line 281 [22.445]

Deletion in pijul-macros/src/lib.rs at line 291 [22.445]

Deletion in pijul-macros/src/lib.rs at line 372 [22.445]

Replacement in pijul-macros/src/lib.rs at line 376 [22.445]

Deletion in pijul-macros/src/lib.rs at line 386 [22.445]

Replacement in pijul-macros/src/lib.rs at line 390 [22.445]

Replacement in pijul-macros/src/lib.rs at line 392 [22.445]

Deletion in pijul-macros/src/lib.rs at line 409 [22.445]

Replacement in pijul-macros/src/lib.rs at line 413 [22.445]

Replacement in pijul-macros/src/lib.rs at line 416 [22.445]

Replacement in pijul-macros/src/lib.rs at line 424 [22.445]

Replacement in pijul-macros/src/lib.rs at line 426 [22.445]

Replacement in pijul-macros/src/lib.rs at line 430 [22.445]

Deletion in pijul-macros/src/lib.rs at line 435 [22.445]

Deletion in pijul-macros/src/lib.rs at line 436 [22.445]

Replacement in pijul-macros/src/lib.rs at line 440 [22.445]

Replacement in pijul-macros/src/lib.rs at line 442 [22.445]

Replacement in pijul-macros/src/lib.rs at line 451 [22.445]

Deletion in pijul-macros/src/lib.rs at line 454 [22.445]

Replacement in pijul-macros/src/lib.rs at line 457 [22.445]

Deletion in pijul-macros/src/lib.rs at line 465 [22.445]

Replacement in pijul-macros/src/lib.rs at line 468 [22.445]

Insertion in pijul-macros/src/lib.rs at line 507 [22.445]

Replacement in pijul-macros/src/lib.rs at line 524 [22.445]

Replacement in pijul-macros/src/lib.rs at line 526 [22.445]

Replacement in pijul-macros/src/lib.rs at line 539 [22.445]

Replacement in pijul-macros/src/lib.rs at line 542 [22.445]

Replacement in pijul-macros/src/lib.rs at line 550 [22.445]

Replacement in pijul-macros/src/lib.rs at line 552 [22.445]

Insertion in pijul-macros/src/lib.rs at line 578 [22.445]

Deletion in pijul-macros/src/lib.rs at line 587 [22.445]

Replacement in pijul-macros/src/lib.rs at line 591 [22.445]

Replacement in pijul-macros/src/lib.rs at line 596 [22.445]

Insertion in pijul-macros/src/lib.rs at line 614 [22.445]

Insertion in pijul-macros/src/lib.rs at line 624 [22.445]

Insertion in pijul-macros/src/lib.rs at line 626 [22.445]

Deletion in pijul-macros/src/lib.rs at line 629 [22.445]

Replacement in pijul-macros/src/lib.rs at line 633 [22.445]

Deletion in pijul-macros/src/lib.rs at line 636 [22.445]

Replacement in pijul-macros/src/lib.rs at line 640 [22.445]

Deletion in pijul-macros/src/lib.rs at line 646 [22.445]

Replacement in pijul-macros/src/lib.rs at line 650 [22.445]

Replacement in pijul-macros/src/lib.rs at line 653 [22.445]

Deletion in pijul-macros/src/lib.rs at line 655 [22.445]

Replacement in pijul-macros/src/lib.rs at line 659 [22.445]

Replacement in pijul-macros/src/lib.rs at line 662 [22.445]

Replacement in pijul-macros/Cargo.toml at line 4 [22.21011]

Insertion in pijul/src/repository.rs at line 4 [22.21431]

Replacement in pijul/src/repository.rs at line 8 [22.21431]

Replacement in pijul/src/repository.rs at line 45 [22.21431]

Replacement in pijul/src/repository.rs at line 74 [22.21431]

Replacement in pijul/src/repository.rs at line 114 [22.21431]

Deletion in pijul/src/remote/ssh.rs at line 21 [22.25380]

Replacement in pijul/src/remote/ssh.rs at line 103 [22.25380]

Replacement in pijul/src/remote/ssh.rs at line 561 [22.25380]