ilyagr/pijul - Change QWIYNMI5SOTLRPYE4O3AG7R75JXM2TB3ZADU646PG6ACPBGSYUYAC

Formatting + big-endian Sanakirja

Created by pmeunier on February 7, 2024

QWIYNMI5SOTLRPYE4O3AG7R75JXM2TB3ZADU646PG6ACPBGSYUYAC

Dependencies

In channels

main

Change contents

Replacement in pijul/src/remote/mod.rs at line 789 [28.52474]

B:BD[27.13011] → [24.0:88]

                debug!("update_changelist_pushpull line {}, {:?} {:?}", line!(), n, h);

[27.13011]

                debug!(
                    "update_changelist_pushpull line {}, {:?} {:?}",
                    line!(),
                    n,
                    h
                );

Replacement in pijul/src/remote/mod.rs at line 1286 [28.52474]
B:BD[10.30] → [10.30:60]
```
                return Ok(())
```
[10.30]
[10.60]
```
                return Ok(());
```

Replacement in pijul/src/remote/mod.rs at line 1382 [28.52474]

B:BD[29.593] → [30.604:703]

            .download_changes_rec(repo, send_hash, recv_signal, send_ready, pro_n, waiting, asked)

[29.593]

[31.3566]

            .download_changes_rec(
                repo,
                send_hash,
                recv_signal,
                send_ready,
                pro_n,
                waiting,
                asked,
            )

Replacement in pijul/src/remote/http.rs at line 41 [33.10]

B:BD[27.24470] → [32.557:628]

    tokio::fs::create_dir_all(&path.parent().unwrap()).await.unwrap();

[27.24470]

[34.314]

    tokio::fs::create_dir_all(&path.parent().unwrap())
        .await
        .unwrap();

Replacement in pijul/src/remote/http.rs at line 167 [33.10]
B:BD[30.1410] → [30.1410:1435]
```
                continue
```
[30.1410]
[30.1435]
```
                continue;
```
Replacement in pijul/src/remote/http.rs at line 173 [33.10]
B:BD[30.1626] → [30.1626:1652]
```
                    break
```
[30.1626]
[30.1652]
```
                    break;
```

Replacement in pijul/src/remote/http.rs at line 541 [33.10]

B:BD[32.1930] → [32.1930:2044]

    pub async fn prove(
        &mut self,
        key: libpijul::key::SKey,
    ) -> Result<(), anyhow::Error> {

[32.1930]

[32.2044]

    pub async fn prove(&mut self, key: libpijul::key::SKey) -> Result<(), anyhow::Error> {

Replacement in pijul/src/identity/mod.rs at line 133 [37.15627]

B:BD[35.4106] → [36.280:382]

            if let Ok(password) = keyring::Entry::new("pijul", name).and_then(|x| x.get_password()) {

[35.4106]

[35.4192]

            if let Ok(password) = keyring::Entry::new("pijul", name).and_then(|x| x.get_password())
            {

Replacement in pijul/src/identity/mod.rs at line 149 [37.15627]

B:BD[35.4743] → [36.383:496]

            if let Err(e) = keyring::Entry::new("pijul", name).and_then(|x| x.set_password(&password_attempt)) {

[35.4743]

[38.317]

            if let Err(e) =
                keyring::Entry::new("pijul", name).and_then(|x| x.set_password(&password_attempt))
            {

Replacement in pijul/src/identity/mod.rs at line 272 [37.15627]

B:BD[35.7658] → [36.497:613]

            if let Err(e) = keyring::Entry::new("pijul", &self.name).and_then(|x| x.set_password(&user_password)) {

[35.7658]

[38.488]

            if let Err(e) = keyring::Entry::new("pijul", &self.name)
                .and_then(|x| x.set_password(&user_password))
            {

Insertion in pijul/src/identity/create.rs at line 8 [37.28175]
[37.28402]
[37.28402]
```
use crate::config;
```
Deletion in pijul/src/identity/create.rs at line 12 [37.28175]
B:BD[37.28571] → [35.8736:8770]
```
use thrussh_keys::key::PublicKey;
```
Replacement in pijul/src/identity/create.rs at line 14 [37.28175]
B:BD[19.31] → [19.31:50]
```
use crate::config;
```
[19.31]
[37.28571]
```
use thrussh_keys::key::PublicKey;
```

Replacement in pijul/src/commands/tag.rs at line 290 [39.74]

B:BD[39.5248] → [22.0:127]

            chrono::DateTime::from_naive_utc_and_offset(chrono::NaiveDateTime::from_timestamp_opt(t, 0).unwrap(), chrono::Utc)

[39.5248]

[39.5345]

            chrono::DateTime::from_naive_utc_and_offset(
                chrono::NaiveDateTime::from_timestamp_opt(t, 0).unwrap(),
                chrono::Utc,
            )

Replacement in pijul/src/commands/protocol.rs at line 413 [28.123281]
B:BD[40.2669] → [14.492:524]
```
                return Ok(true)
```
[40.2669]
[40.2669]
```
                return Ok(true);
```

Replacement in pijul/src/commands/identity.rs at line 443 [37.40825]

B:BD[35.19585] → [36.1057:1165]

                    if let Err(e) = Entry::new("pijul", &identity.name).and_then(|x| x.delete_password()) {

[35.19585]

[41.108]

                    if let Err(e) =
                        Entry::new("pijul", &identity.name).and_then(|x| x.delete_password())
                    {

Deletion in pijul/src/commands/dependents.rs at line 1 [42.243]
B:BD[42.243] → [42.244:288]
```
use std::path::PathBuf;
use std::io::Write;
```
Insertion in pijul/src/commands/dependents.rs at line 3 [42.243]
[42.323]
[42.323]
```
use std::io::Write;
use std::path::PathBuf;
```
Replacement in pijul/src/commands/dependents.rs at line 37 [42.243]
B:BD[16.450] → [16.450:480]
```
                return Ok(())
```
[16.450]
[42.1076]
```
                return Ok(());
```
Replacement in pijul/src/commands/dependents.rs at line 65 [42.243]
B:BD[16.856] → [16.856:886]
```
                        break
```
[16.856]
[16.886]
```
                        break;
```

Replacement in pijul/src/commands/debug.rs at line 55 [28.177758]

B:BD[43.518] → [43.518:629]

                        txn
                            .follow_oldest_path(&repo.changes, &channel, &root)?.0

[43.518]

[43.629]

                        txn.follow_oldest_path(&repo.changes, &channel, &root)?.0

Replacement in pijul/src/commands/debug.rs at line 84 [28.177758]

B:BD[43.805] → [43.805:939]

    if let (Some(a), Some(b)) = (it.next(),it.next()) {
        use libpijul::pristine::{Position, ChangeId, ChangePosition, Base32};

[43.805]

[43.939]

    if let (Some(a), Some(b)) = (it.next(), it.next()) {
        use libpijul::pristine::{Base32, ChangeId, ChangePosition, Position};

Insertion in pijul/src/commands/client.rs at line 3 [32.4568]

[32.4588]

use crate::config::global_config_dir;
use hyper::service::{make_service_fn, service_fn};
use hyper::{Body, Request, Response, Server};

Deletion in pijul/src/commands/client.rs at line 8 [32.4568]

B:BD[32.4644] → [32.4644:4773]

use hyper::{Body, Request, Response, Server};
use hyper::service::{make_service_fn, service_fn};
use tokio::sync::mpsc::channel;

Replacement in pijul/src/commands/client.rs at line 9 [32.4568]
B:BD[32.4792] → [32.4792:4830]
```
use crate::config::global_config_dir;
```
[32.4792]
[32.4830]
```
use tokio::sync::mpsc::channel;
```
Deletion in pijul/src/commands/client.rs at line 20 [32.4568]
B:BD[32.5032] → [32.5032:5033]
Replacement in pijul/src/commands/client.rs at line 29 [32.4568]
B:BD[32.5461] → [32.5461:5495]
```
                    return Ok(())
```
[32.5461]
[32.5495]
```
                    return Ok(());
```
Deletion in pijul/src/commands/client.rs at line 36 [32.4568]
B:BD[32.5610] → [32.5610:5611]

Replacement in pijul/src/commands/client.rs at line 65 [32.4568]

B:BD[32.6965] → [32.6965:7011]

                                    .unwrap()

[32.6965]

[32.7011]

                                    .unwrap(),

Replacement in pijul/src/commands/client.rs at line 80 [32.4568]

∅:D[21.60] → [44.11272:11362]

B:BD[32.7541] → [44.11272:11362]

                eprintln!("If the URL doesn't open automatically, please visit {}", url);

[21.60]

[32.7541]

                eprintln!(
                    "If the URL doesn't open automatically, please visit {}",
                    url
                );

Replacement in pijul/src/commands/client.rs at line 85 [32.4568]
B:BD[32.7598] → [32.7598:7623]
```
                select!{
```
[32.7598]
[32.7623]
```
                select! {
```
Replacement in pijul/src/commands/client.rs at line 111 [32.4568]
B:BD[32.8334] → [32.8334:8356]
```
                break
```
[32.8334]
[32.8356]
```
                break;
```

Replacement in pijul/src/commands/apply.rs at line 139 [28.194289]

B:BD[13.188] → [13.188:221]

                        continue

[13.188]

[13.221]

                        continue;

Replacement in pijul/Cargo.toml at line 82 [28.196374]

B:BD[28.197874] → [45.0:85]

sanakirja = { version = "1.2.16", default-features = false, features = [ "crc32" ] }

[28.197874]

[28.197895]

sanakirja = { version = "1.4.0", default-features = false, features = [ "crc32" ] }

Replacement in libpijul/src/vertex_buffer.rs at line 165 [28.217202]

B:BD[28.221091] → [46.0:91]

            changes: sides.iter().flat_map(|(_, b)| b.iter()).cloned().cloned().collect(),

[28.221091]

[47.796]

            changes: sides
                .iter()
                .flat_map(|(_, b)| b.iter())
                .cloned()
                .cloned()
                .collect(),

Replacement in libpijul/src/vertex_buffer.rs at line 184 [28.217202]

B:BD[28.221363] → [46.92:185]

            changes: add_del.iter().flat_map(|(_, b)| b.iter()).cloned().cloned().collect(),

[28.221363]

[47.926]

            changes: add_del
                .iter()
                .flat_map(|(_, b)| b.iter())
                .cloned()
                .cloned()
                .collect(),

Replacement in libpijul/src/vertex_buffer.rs at line 204 [28.217202]

B:BD[28.221703] → [46.186:309]

    fn conflict_next<C: ChangeStore>(&mut self, id_: usize, sides: Option<(&C, &[&Hash])>) -> Result<(), std::io::Error> {

[28.221703]

[47.1133]

    fn conflict_next<C: ChangeStore>(
        &mut self,
        id_: usize,
        sides: Option<(&C, &[&Hash])>,
    ) -> Result<(), std::io::Error> {

Replacement in libpijul/src/vertex_buffer.rs at line 229 [28.217202]

B:BD[46.774] → [12.0:151]

        Ok(header) => if let Some(l) = header.message.lines().next() {
            l.to_string()
        } else {
            String::new()
        },

[46.774]

[46.848]

        Ok(header) => {
            if let Some(l) = header.message.lines().next() {
                l.to_string()
            } else {
                String::new()
            }
        }

Deletion in libpijul/src/unrecord/mod.rs at line 589 [28.231493]
B:BD[48.2201] → [43.1690:1691]
Replacement in libpijul/src/unrecord/mod.rs at line 611 [28.231493]
B:BD[43.2511] → [43.2511:2532]
```
            continue
```
[43.2511]
[43.2532]
```
            continue;
```
Replacement in libpijul/src/unrecord/mod.rs at line 629 [28.231493]
B:BD[43.3143] → [43.3143:3168]
```
                continue
```
[43.3143]
[43.3168]
```
                continue;
```
Deletion in libpijul/src/unrecord/mod.rs at line 659 [28.231493]
B:BD[43.4017] → [43.4017:4018]
Deletion in libpijul/src/unrecord/mod.rs at line 674 [28.231493]
B:BD[48.2923] → [43.4099:4100]
Replacement in libpijul/src/unrecord/mod.rs at line 680 [28.231493]
B:BD[43.4413] → [43.4413:4439]
```
                    break
```
[43.4413]
[43.4439]
```
                    break;
```
Deletion in libpijul/src/unrecord/mod.rs at line 695 [28.231493]
B:BD[28.238933] → [28.238933:238934]
Solving an order conflict in libpijul/src/unrecord/mod.rs at line 695 [28.231493]
[49.3885]

Replacement in libpijul/src/tests/file_conflicts.rs at line 1216 [28.305506]

B:BD[50.646] → [8.708:813]

        Conflict::ZombieFile { ref path, .. } => assert!(path == "a/b/c/file" || path == "a/b/c/alice"),

[50.646]

[28.345145]

        Conflict::ZombieFile { ref path, .. } => {
            assert!(path == "a/b/c/file" || path == "a/b/c/alice")
        }

Replacement in libpijul/src/tests/file_conflicts.rs at line 1238 [28.305506]

B:BD[50.692] → [8.814:919]

        Conflict::ZombieFile { ref path, .. } => assert!(path == "a/b/c/file" || path == "a/b/c/alice"),

[50.692]

[28.345703]

        Conflict::ZombieFile { ref path, .. } => {
            assert!(path == "a/b/c/file" || path == "a/b/c/alice")
        }

Replacement in libpijul/src/tag.rs at line 169 [39.6397]

B:BD[39.8872] → [39.8872:8945]

        ::sanakirja::btree::Db_::from_page(tag.header.offsets.external);

[39.8872]

[51.1311]

        unsafe { ::sanakirja::btree::Db_::from_page(tag.header.offsets.external) };

Replacement in libpijul/src/tag.rs at line 317 [39.6397]

B:BD[39.12934] → [39.12934:13025]

    fn load_page(&self, off: u64) -> Result<::sanakirja::CowPage, ::sanakirja::CRCError> {

[39.12934]

[39.13025]

    unsafe fn load_page(&self, off: u64) -> Result<::sanakirja::CowPage, ::sanakirja::CRCError> {

Replacement in libpijul/src/tag.rs at line 346 [39.6397]
B:BD[39.13707] → [39.13707:13745]
```
    let page = txn.txn.alloc_page()?;
```
[39.13707]
[39.13745]
```
    let page = unsafe { txn.txn.alloc_page()? };
```

Replacement in libpijul/src/tag.rs at line 374 [39.6397]

B:BD[39.14586] → [39.14586:14640]

                let new_page = txn.txn.alloc_page()?;

[39.14586]

[39.14640]

                let new_page = unsafe { txn.txn.alloc_page()? };

Replacement in libpijul/src/tag.rs at line 381 [39.6397]

B:BD[39.14804] → [3.0:76]

            unsafe { P::put_mut(&mut new_page_, &mut new_curs, &k, &v, r) }

[39.14804]

[39.14876]

            unsafe { P::put_mut(&mut txn.txn, &mut new_page_, &mut new_curs, &k, &v, r) }

Replacement in libpijul/src/tag.rs at line 385 [39.6397]

B:BD[39.14933] → [39.14933:14984]

    Ok(::sanakirja::btree::Db_::from_page(result))

[39.14933]

[39.14984]

    Ok(unsafe { ::sanakirja::btree::Db_::from_page(result) })

Replacement in libpijul/src/tag.rs at line 479 [39.6397]
B:BD[39.18233] → [39.18233:18258]
```
        txn.internal.db,
```
[39.18233]
[39.18258]
```
        txn.internal.db.into(),
```
Replacement in libpijul/src/tag.rs at line 487 [39.6397]
B:BD[39.18452] → [39.18452:18477]
```
        txn.external.db,
```
[39.18452]
[39.18477]
```
        txn.external.db.into(),
```
Replacement in libpijul/src/tag.rs at line 495 [39.6397]
B:BD[39.18680] → [39.18680:18706]
```
        channel.graph.db,
```
[39.18680]
[39.18706]
```
        channel.graph.db.into(),
```
Replacement in libpijul/src/tag.rs at line 503 [39.6397]
B:BD[39.18875] → [39.18875:18903]
```
        channel.changes.db,
```
[39.18875]
[39.18903]
```
        channel.changes.db.into(),
```

Replacement in libpijul/src/tag.rs at line 514 [39.6397]

B:BD[39.19146] → [39.19146:19214]

    >(&txn, channel.revchanges.db, &mut new, &sender, &breceiver)?;

[39.19146]

[39.19214]

    >(
        &txn,
        channel.revchanges.db.into(),
        &mut new,
        &sender,
        &breceiver,
    )?;

Replacement in libpijul/src/tag.rs at line 524 [39.6397]
B:BD[39.19335] → [39.19335:19362]
```
        channel.states.db,
```
[39.19335]
[39.19362]
```
        channel.states.db.into(),
```

Replacement in libpijul/src/tag.rs at line 535 [39.6397]

B:BD[6.302] → [6.302:364]

    >(&txn, channel.tags.db, &mut new, &sender, &breceiver)?;

[6.302]

[39.19601]

    >(&txn, channel.tags.db.into(), &mut new, &sender, &breceiver)?;

Insertion in libpijul/src/tag.rs at line 556 [39.6397]

[39.20036]

struct CopyTxn {}
impl ::sanakirja::AllocPage for CopyTxn {
    /// Allocate a single page.
    unsafe fn alloc_page(&mut self) -> Result<::sanakirja::MutPage, Self::Error> {
        unimplemented!()
    }
    /// Allocate a single page.
    unsafe fn alloc_page_no_dirty(&mut self) -> Result<::sanakirja::MutPage, Self::Error> {
        unimplemented!()
    }
    /// Allocate many contiguous pages, return the first one
    unsafe fn alloc_contiguous(&mut self, _: u64) -> Result<::sanakirja::MutPage, Self::Error> {
        unimplemented!()
    }
    /// Increment the reference count for page `off`.
    fn incr_rc(&mut self, _: u64) -> Result<usize, Self::Error> {
        unimplemented!()
    }
    unsafe fn decr_rc(&mut self, _: u64) -> Result<usize, Self::Error> {
        unimplemented!()
    }
    unsafe fn decr_rc_owned(&mut self, _: u64) -> Result<usize, Self::Error> {
        unimplemented!()
    }
}
impl ::sanakirja::LoadPage for CopyTxn {
    type Error = std::convert::Infallible;
    unsafe fn load_page(&self, _: u64) -> Result<::sanakirja::CowPage, Self::Error> {
        unimplemented!()
    }
}

Replacement in libpijul/src/tag.rs at line 613 [39.6397]

∅:D[4.836] → [39.20669:20730]

B:BD[39.20669] → [39.20669:20730]

        let page = txn.txn.load_page(old_page_off).unwrap();

[4.836]

[39.20730]

        let page = unsafe { txn.txn.load_page(old_page_off).unwrap() };

Replacement in libpijul/src/tag.rs at line 645 [39.6397]

B:BD[39.21785] → [3.77:151]

            unsafe { P::put_mut(&mut new_page_, &mut new_curs, k, v, r) }

[39.21785]

[39.21855]

            unsafe { P::put_mut(&mut CopyTxn {}, &mut new_page_, &mut new_curs, k, v, r) }

Replacement in libpijul/src/tag/txn.rs at line 91 [52.48]

B:BD[52.2116] → [52.2116:2197]

    fn load_page(&self, off: u64) -> Result<::sanakirja::CowPage, Self::Error> {

[52.2116]

[52.2197]

    unsafe fn load_page(&self, off: u64) -> Result<::sanakirja::CowPage, Self::Error> {

Replacement in libpijul/src/tag/txn.rs at line 124 [52.48]

B:BD[52.3286] → [52.3286:3486]

        use crate::pristine::sanakirja::Db;
        let gr: Db<Vertex<ChangeId>, SerializedEdge> = Db::from_page(db.graph);
        Ok(::sanakirja::btree::get(self, &gr, key, value)?.map(|(_, v)| v))

[52.3286]

[52.3486]

        unsafe {
            use crate::pristine::sanakirja::Db;
            let gr: Db<Vertex<ChangeId>, SerializedEdge> = Db::from_page(db.graph);
            Ok(::sanakirja::btree::get(self, &gr, key, value)?.map(|(_, v)| v))
        }

Replacement in libpijul/src/tag/txn.rs at line 135 [52.48]

B:BD[52.3638] → [52.3638:3852]

        use crate::pristine::sanakirja::UDb;
        let gr: UDb<ChangeId, SerializedHash> = UDb::from_page(self.header.offsets.external);
        Ok(::sanakirja::btree::get(self, &gr, int, None)?.map(|(_, v)| v))

[52.3638]

[52.3852]

        unsafe {
            use crate::pristine::sanakirja::UDb;
            let gr: UDb<ChangeId, SerializedHash> = UDb::from_page(self.header.offsets.external);
            Ok(::sanakirja::btree::get(self, &gr, int, None)?.map(|(_, v)| v))
        }

Replacement in libpijul/src/tag/txn.rs at line 146 [52.48]

B:BD[52.4004] → [52.4004:4218]

        use crate::pristine::sanakirja::UDb;
        let gr: UDb<SerializedHash, ChangeId> = UDb::from_page(self.header.offsets.internal);
        Ok(::sanakirja::btree::get(self, &gr, int, None)?.map(|(_, v)| v))

[52.4004]

[52.4218]

        unsafe {
            use crate::pristine::sanakirja::UDb;
            let gr: UDb<SerializedHash, ChangeId> = UDb::from_page(self.header.offsets.internal);
            Ok(::sanakirja::btree::get(self, &gr, int, None)?.map(|(_, v)| v))
        }

Replacement in libpijul/src/tag/txn.rs at line 163 [52.48]

B:BD[52.4509] → [52.4509:4960]

        let edge = SerializedEdge::new(min_flag, dest.change, dest.pos, ChangeId::ROOT);
        use crate::pristine::sanakirja::Db;
        let gr: Db<Vertex<ChangeId>, SerializedEdge> = Db::from_page(g.graph);
        let mut cursor = ::sanakirja::btree::cursor::Cursor::new(self, &gr)?;
        cursor.set(self, &key, Some(&edge))?;
        Ok(Self::Adj {
            cursor,
            key,
            min_flag,
            max_flag,
        })

[52.4509]

[52.4960]

        unsafe {
            let edge = SerializedEdge::new(min_flag, dest.change, dest.pos, ChangeId::ROOT);
            use crate::pristine::sanakirja::Db;
            let gr: Db<Vertex<ChangeId>, SerializedEdge> = Db::from_page(g.graph);
            let mut cursor = ::sanakirja::btree::cursor::Cursor::new(self, &gr)?;
            cursor.set(self, &key, Some(&edge))?;
            Ok(Self::Adj {
                cursor,
                key,
                min_flag,
                max_flag,
            })
        }

Replacement in libpijul/src/tag/txn.rs at line 191 [52.48]

B:BD[52.5393] → [52.5393:5586]

        use crate::pristine::sanakirja::Db;
        let gr: Db<Vertex<ChangeId>, SerializedEdge> = Db::from_page(graph.graph);
        Ok(crate::pristine::sanakirja::find_block(self, &gr, p)?)

[52.5393]

[52.5586]

        unsafe {
            use crate::pristine::sanakirja::Db;
            let gr: Db<Vertex<ChangeId>, SerializedEdge> = Db::from_page(graph.graph);
            Ok(crate::pristine::sanakirja::find_block(self, &gr, p)?)
        }

Replacement in libpijul/src/tag/txn.rs at line 203 [52.48]

B:BD[52.5758] → [52.5758:5955]

        use crate::pristine::sanakirja::Db;
        let gr: Db<Vertex<ChangeId>, SerializedEdge> = Db::from_page(graph.graph);
        Ok(crate::pristine::sanakirja::find_block_end(self, &gr, p)?)

[52.5758]

[52.5955]

        unsafe {
            use crate::pristine::sanakirja::Db;
            let gr: Db<Vertex<ChangeId>, SerializedEdge> = Db::from_page(graph.graph);
            Ok(crate::pristine::sanakirja::find_block_end(self, &gr, p)?)
        }

Replacement in libpijul/src/tag/txn.rs at line 253 [52.48]

B:BD[52.7265] → [52.7265:7584]

        use crate::pristine::sanakirja::Db;
        let db: Db<ChangeId, L64> = Db::from_page(*channel);
        match ::sanakirja::btree::get(self, &db, c, None) {
            Ok(Some((k, x))) if k == c => Ok(Some(x)),
            Ok(x) => {
                debug!("get_changeset = {:?}", x);
                Ok(None)

[52.7265]

[52.7584]

        unsafe {
            use crate::pristine::sanakirja::Db;
            let db: Db<ChangeId, L64> = Db::from_page(*channel);
            match ::sanakirja::btree::get(self, &db, c, None) {
                Ok(Some((k, x))) if k == c => Ok(Some(x)),
                Ok(x) => {
                    debug!("get_changeset = {:?}", x);
                    Ok(None)
                }
                Err(e) => {
                    error!("{:?}", e);
                    Err(TxnErr(SanakirjaError::PristineCorrupt).into())
                }

Deletion in libpijul/src/tag/txn.rs at line 267 [52.48]

B:BD[52.7598] → [52.7598:7725]

B:BD[52.7725] → [52.7725:7739]

            Err(e) => {
                error!("{:?}", e);
                Err(TxnErr(SanakirjaError::PristineCorrupt).into())
            }

Replacement in libpijul/src/tag/txn.rs at line 275 [52.48]

B:BD[52.7941] → [52.7941:8349]

        use crate::pristine::sanakirja::UDb;
        let db: UDb<L64, Pair<ChangeId, SerializedMerkle>> = UDb::from_page(*revchanges);
        match ::sanakirja::btree::get(self, &db, c, None) {
            Ok(Some((k, x))) if k == c => Ok(Some(x)),
            Ok(_) => Ok(None),
            Err(e) => {
                error!("{:?}", e);
                Err(TxnErr(SanakirjaError::PristineCorrupt).into())

[52.7941]

[52.8349]

        unsafe {
            use crate::pristine::sanakirja::UDb;
            let db: UDb<L64, Pair<ChangeId, SerializedMerkle>> = UDb::from_page(*revchanges);
            match ::sanakirja::btree::get(self, &db, c, None) {
                Ok(Some((k, x))) if k == c => Ok(Some(x)),
                Ok(_) => Ok(None),
                Err(e) => {
                    error!("{:?}", e);
                    Err(TxnErr(SanakirjaError::PristineCorrupt).into())
                }

Replacement in libpijul/src/tag/txn.rs at line 297 [52.48]

B:BD[52.8692] → [52.8692:8947]

        use crate::pristine::sanakirja::Db;
        let db: Db<ChangeId, L64> = Db::from_page(*channel);
        let mut cursor = ::sanakirja::btree::cursor::Cursor::new(self, &db)?;
        if let Some(k) = pos {
            cursor.set(self, &k, None)?;

[52.8692]

[52.8947]

        unsafe {
            use crate::pristine::sanakirja::Db;
            let db: Db<ChangeId, L64> = Db::from_page(*channel);
            let mut cursor = ::sanakirja::btree::cursor::Cursor::new(self, &db)?;
            if let Some(k) = pos {
                cursor.set(self, &k, None)?;
            }
            Ok(Cursor {
                cursor,
                txn: self,
                k: std::marker::PhantomData,
                v: std::marker::PhantomData,
                t: std::marker::PhantomData,
            })

Deletion in libpijul/src/tag/txn.rs at line 312 [52.48]

B:BD[52.8957] → [52.8957:9154]

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

Replacement in libpijul/src/tag/txn.rs at line 328 [52.48]

B:BD[52.9636] → [52.9636:9920]

        use crate::pristine::sanakirja::UDb;
        let db: UDb<L64, Pair<ChangeId, SerializedMerkle>> = UDb::from_page(*channel);
        let mut cursor = ::sanakirja::btree::cursor::Cursor::new(&*txn, &db)?;
        if let Some(k) = pos {
            cursor.set(&*txn, &k, None)?;

[52.9636]

[52.9920]

        unsafe {
            use crate::pristine::sanakirja::UDb;
            let db: UDb<L64, Pair<ChangeId, SerializedMerkle>> = UDb::from_page(*channel);
            let mut cursor = ::sanakirja::btree::cursor::Cursor::new(&*txn, &db)?;
            if let Some(k) = pos {
                cursor.set(&*txn, &k, None)?;
            }
            Ok(Cursor {
                cursor,
                txn,
                k: std::marker::PhantomData,
                v: std::marker::PhantomData,
                t: std::marker::PhantomData,
            })

Deletion in libpijul/src/tag/txn.rs at line 343 [52.48]

B:BD[52.9930] → [52.9930:10121]

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

Replacement in libpijul/src/tag/txn.rs at line 353 [52.48]

B:BD[52.10397] → [52.10397:10950]

        use crate::pristine::sanakirja::UDb;
        let db: UDb<L64, Pair<ChangeId, SerializedMerkle>> = UDb::from_page(*channel);
        let mut cursor = ::sanakirja::btree::cursor::Cursor::new(self, &db)?;
        if let Some(ref pos) = pos {
            cursor.set(self, pos, None)?;
        } else {
            cursor.set_last(self)?;
        };
        Ok(RevCursor {
            cursor,
            txn: self,
            k: std::marker::PhantomData,
            v: std::marker::PhantomData,
            t: std::marker::PhantomData,
        })

[52.10397]

[52.10950]

        unsafe {
            use crate::pristine::sanakirja::UDb;
            let db: UDb<L64, Pair<ChangeId, SerializedMerkle>> = UDb::from_page(*channel);
            let mut cursor = ::sanakirja::btree::cursor::Cursor::new(self, &db)?;
            if let Some(ref pos) = pos {
                cursor.set(self, pos, None)?;
            } else {
                cursor.set_last(self)?;
            };
            Ok(RevCursor {
                cursor,
                txn: self,
                k: std::marker::PhantomData,
                v: std::marker::PhantomData,
                t: std::marker::PhantomData,
            })
        }

Replacement in libpijul/src/tag/txn.rs at line 419 [52.48]

B:BD[52.12419] → [52.12419:12675]

        use crate::pristine::sanakirja::UDb;
        let db: UDb<SerializedMerkle, L64> = UDb::from_page(*channel);
        match ::sanakirja::btree::get(self, &db, m, None)? {
            Some((k, v)) if k == m => Ok(Some(*v)),
            _ => Ok(None),

[52.12419]

[52.12675]

        unsafe {
            use crate::pristine::sanakirja::UDb;
            let db: UDb<SerializedMerkle, L64> = UDb::from_page(*channel);
            match ::sanakirja::btree::get(self, &db, m, None)? {
                Some((k, v)) if k == m => Ok(Some(*v)),
                _ => Ok(None),
            }

Replacement in libpijul/src/tag/txn.rs at line 436 [52.48]

B:BD[53.2496] → [53.2496:2540]

B:BD[53.2540] → [27.39095:39185]

∅:D[27.39185] → [53.2592:2726]

B:BD[53.2592] → [53.2592:2726]

B:BD[53.2726] → [6.894:922]

        use crate::pristine::sanakirja::Db;
        let db: Db<L64, Pair<SerializedMerkle, SerializedMerkle>> = Db::from_page(*tags);
        let t: L64 = t.into();
        match ::sanakirja::btree::get(self, &db, &t, None)? {
            Some((k, _)) => Ok(k == &t),
            _ => Ok(false),

[53.2496]

[52.13093]

        unsafe {
            use crate::pristine::sanakirja::Db;
            let db: Db<L64, Pair<SerializedMerkle, SerializedMerkle>> = Db::from_page(*tags);
            let t: L64 = t.into();
            match ::sanakirja::btree::get(self, &db, &t, None)? {
                Some((k, _)) => Ok(k == &t),
                _ => Ok(false),
            }

Replacement in libpijul/src/tag/txn.rs at line 461 [52.48]

B:BD[52.13471] → [53.2833:2877]

B:BD[53.2877] → [27.39303:39396]

∅:D[53.2932] → [52.13585:13733]

∅:D[27.39396] → [52.13585:13733]

B:BD[52.13585] → [52.13585:13733]

        use crate::pristine::sanakirja::Db;
        let db: Db<L64, Pair<SerializedMerkle, SerializedMerkle>> = Db::from_page(*channel);
        let mut cursor = ::sanakirja::btree::cursor::Cursor::new(self, &db)?;
        if let Some(k) = k {
            cursor.set(self, &k, None)?;

[52.13471]

[52.13733]

        unsafe {
            use crate::pristine::sanakirja::Db;
            let db: Db<L64, Pair<SerializedMerkle, SerializedMerkle>> = Db::from_page(*channel);
            let mut cursor = ::sanakirja::btree::cursor::Cursor::new(self, &db)?;
            if let Some(k) = k {
                cursor.set(self, &k, None)?;
            }
            Ok(Cursor {
                cursor,
                txn: self,
                k: std::marker::PhantomData,
                v: std::marker::PhantomData,
                t: std::marker::PhantomData,
            })

Deletion in libpijul/src/tag/txn.rs at line 476 [52.48]

B:BD[52.13743] → [52.13743:13940]

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

Replacement in libpijul/src/tag/txn.rs at line 532 [52.48]

B:BD[52.15103] → [53.3272:3316]

B:BD[53.3316] → [27.39870:39963]

∅:D[53.3371] → [52.15217:15645]

∅:D[27.39963] → [52.15217:15645]

B:BD[52.15217] → [52.15217:15645]

        use crate::pristine::sanakirja::Db;
        let db: Db<L64, Pair<SerializedMerkle, SerializedMerkle>> = Db::from_page(*channel);
        let mut cursor = ::sanakirja::btree::cursor::Cursor::new(self, &db)?;
        if let Some(from) = from {
            cursor.set(self, &from.into(), None)?;
        } else {
            cursor.set_last(self)?;
        };
        Ok(RevCursor {
            cursor,
            txn: self,
            k: std::marker::PhantomData,
            v: std::marker::PhantomData,
            t: std::marker::PhantomData,
        })

[52.15103]

[52.15645]

        unsafe {
            use crate::pristine::sanakirja::Db;
            let db: Db<L64, Pair<SerializedMerkle, SerializedMerkle>> = Db::from_page(*channel);
            let mut cursor = ::sanakirja::btree::cursor::Cursor::new(self, &db)?;
            if let Some(from) = from {
                cursor.set(self, &from.into(), None)?;
            } else {
                cursor.set_last(self)?;
            };
            Ok(RevCursor {
                cursor,
                txn: self,
                k: std::marker::PhantomData,
                v: std::marker::PhantomData,
                t: std::marker::PhantomData,
            })
        }

Replacement in libpijul/src/small_string.rs at line 314 [28.480474]

B:BD[28.487787] → [54.47547:47596]

    unsafe fn write_to_page(&self, p: *mut u8) {

[28.487787]

[54.47596]

    unsafe fn write_to_page<T: sanakirja::AllocPage>(&self, _: &mut T, p: *mut u8) {

Insertion in libpijul/src/record.rs at line 942 [28.488880]

[55.5233]

[56.7939]

                debug!(
                    "add root if needed {:?} {:?}",
                    pos.0.as_u64(),
                    pos2.0.as_u64()
                );

Insertion in libpijul/src/record.rs at line 1047 [28.488880]
[57.1294]
[57.1294]
```
        debug!("name start {:?} end {:?}", name_start, name_end);
```
Replacement in libpijul/src/record.rs at line 1747 [28.488880]
B:BD[11.891] → [11.891:912]
```
            continue
```
[11.891]
[11.912]
```
            continue;
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 135 [28.531056]
B:BD[39.22192] → [39.22192:22232]
```
const VERSION: L64 = L64(1u64.to_le());
```
[39.22192]
[28.532726]
```
const VERSION: u64 = 1u64;
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 140 [28.531056]

B:BD[28.532869] → [39.22233:22295]

        if L64(txn.root(Root::Version as usize)) != VERSION {

[28.532869]

[39.22295]

        if txn.root(Root::Version as usize) != VERSION {

Insertion in libpijul/src/pristine/sanakirja.rs at line 143 [28.531056]
[39.22354]
[54.57378]
```
        debug!("txn_begin");
```
Insertion in libpijul/src/pristine/sanakirja.rs at line 166 [28.531056]
[28.533977]
[28.533977]
```
        debug!("txn begin done");
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 179 [28.531056]

∅:D[58.1263] → [28.534173:534255]

∅:D[39.22427] → [28.534173:534255]

B:BD[28.534173] → [28.534173:534255]

B:BD[28.534255] → [39.22428:22595]

        let mut txn = ::sanakirja::Env::mut_txn_begin(self.env.clone()).unwrap();
        if let Some(version) = txn.root(Root::Version as usize) {
            if L64(version) != VERSION {
                return Err(SanakirjaError::Version.into());

[39.22427]

[39.22595]

        unsafe {
            let mut txn = ::sanakirja::Env::mut_txn_begin(self.env.clone()).unwrap();
            if let Some(version) = txn.root(Root::Version as usize) {
                if version != VERSION {
                    return Err(SanakirjaError::Version.into());
                }
            } else {
                txn.set_root(Root::Version as usize, VERSION);

Replacement in libpijul/src/pristine/sanakirja.rs at line 188 [28.531056]

B:BD[39.22609] → [39.22609:22687]

        } else {
            txn.set_root(Root::Version as usize, VERSION.0);

[39.22609]

[39.22687]

            Ok(MutTxn {
                channels: if let Some(db) = txn.root_db(Root::Channels as usize) {
                    db
                } else {
                    btree::create_db_(&mut txn)?
                },
                external: if let Some(db) = txn.root_db(Root::External as usize) {
                    db
                } else {
                    btree::create_db_(&mut txn)?
                },
                internal: if let Some(db) = txn.root_db(Root::Internal as usize) {
                    db
                } else {
                    btree::create_db_(&mut txn)?
                },
                inodes: if let Some(db) = txn.root_db(Root::Inodes as usize) {
                    db
                } else {
                    btree::create_db_(&mut txn)?
                },
                revinodes: if let Some(db) = txn.root_db(Root::RevInodes as usize) {
                    db
                } else {
                    btree::create_db_(&mut txn)?
                },
                tree: if let Some(db) = txn.root_db(Root::Tree as usize) {
                    db
                } else {
                    btree::create_db_(&mut txn)?
                },
                revtree: if let Some(db) = txn.root_db(Root::RevTree as usize) {
                    db
                } else {
                    btree::create_db_(&mut txn)?
                },
                revdep: if let Some(db) = txn.root_db(Root::RevDep as usize) {
                    db
                } else {
                    btree::create_db_(&mut txn)?
                },
                dep: if let Some(db) = txn.root_db(Root::Dep as usize) {
                    db
                } else {
                    btree::create_db_(&mut txn)?
                },
                touched_files: if let Some(db) = txn.root_db(Root::TouchedFiles as usize) {
                    db
                } else {
                    btree::create_db_(&mut txn)?
                },
                rev_touched_files: if let Some(db) = txn.root_db(Root::RevTouchedFiles as usize) {
                    db
                } else {
                    btree::create_db_(&mut txn)?
                },
                partials: if let Some(db) = txn.root_db(Root::Partials as usize) {
                    db
                } else {
                    btree::create_db_(&mut txn)?
                },
                remotes: if let Some(db) = txn.root_db(Root::Remotes as usize) {
                    db
                } else {
                    btree::create_db_(&mut txn)?
                },
                open_channels: Mutex::new(HashMap::default()),
                open_remotes: Mutex::new(HashMap::default()),
                txn,
                counter: 0,
                cur_channel: None,
            })

Deletion in libpijul/src/pristine/sanakirja.rs at line 261 [28.531056]

∅:D[39.22697] → [58.1264:3608]

B:BD[28.534255] → [58.1264:3608]

B:BD[58.3608] → [59.61706:61823]

∅:D[59.61823] → [28.536168:536185]

B:BD[28.536168] → [28.536168:536185]

B:BD[28.536185] → [59.61824:61848]

B:BD[59.61848] → [60.5403:5434]

∅:D[60.5434] → [58.3609:3620]

∅:D[59.61848] → [58.3609:3620]

B:BD[28.536185] → [58.3609:3620]

        Ok(MutTxn {
            channels: if let Some(db) = txn.root_db(Root::Channels as usize) {
                db
            } else {
                btree::create_db_(&mut txn)?
            },
            external: if let Some(db) = txn.root_db(Root::External as usize) {
                db
            } else {
                btree::create_db_(&mut txn)?
            },
            internal: if let Some(db) = txn.root_db(Root::Internal as usize) {
                db
            } else {
                btree::create_db_(&mut txn)?
            },
            inodes: if let Some(db) = txn.root_db(Root::Inodes as usize) {
                db
            } else {
                btree::create_db_(&mut txn)?
            },
            revinodes: if let Some(db) = txn.root_db(Root::RevInodes as usize) {
                db
            } else {
                btree::create_db_(&mut txn)?
            },
            tree: if let Some(db) = txn.root_db(Root::Tree as usize) {
                db
            } else {
                btree::create_db_(&mut txn)?
            },
            revtree: if let Some(db) = txn.root_db(Root::RevTree as usize) {
                db
            } else {
                btree::create_db_(&mut txn)?
            },
            revdep: if let Some(db) = txn.root_db(Root::RevDep as usize) {
                db
            } else {
                btree::create_db_(&mut txn)?
            },
            dep: if let Some(db) = txn.root_db(Root::Dep as usize) {
                db
            } else {
                btree::create_db_(&mut txn)?
            },
            touched_files: if let Some(db) = txn.root_db(Root::TouchedFiles as usize) {
                db
            } else {
                btree::create_db_(&mut txn)?
            },
            rev_touched_files: if let Some(db) = txn.root_db(Root::RevTouchedFiles as usize) {
                db
            } else {
                btree::create_db_(&mut txn)?
            },
            partials: if let Some(db) = txn.root_db(Root::Partials as usize) {
                db
            } else {
                btree::create_db_(&mut txn)?
            },
            remotes: if let Some(db) = txn.root_db(Root::Remotes as usize) {
                db
            } else {
                btree::create_db_(&mut txn)?
            },
            open_channels: Mutex::new(HashMap::default()),
            open_remotes: Mutex::new(HashMap::default()),
            txn,
            counter: 0,
            cur_channel: None,
        })

Replacement in libpijul/src/pristine/sanakirja.rs at line 317 [28.531056]

B:BD[61.330] → [61.330:369]

∅:D[61.369] → [54.60694:60754]

B:BD[54.60694] → [54.60694:60754]

B:BD[54.60754] → [61.370:428]

∅:D[61.428] → [54.60839:60899]

B:BD[54.60839] → [54.60839:60899]

B:BD[54.60899] → [61.429:487]

∅:D[61.487] → [54.60984:61040]

B:BD[54.60984] → [54.60984:61040]

B:BD[54.61040] → [61.488:544]

∅:D[61.544] → [54.61123:61185]

B:BD[54.61123] → [54.61123:61185]

B:BD[54.61185] → [61.545:604]

∅:D[61.604] → [54.61271:61323]

B:BD[54.61271] → [54.61271:61323]

B:BD[54.61323] → [61.605:659]

∅:D[61.659] → [54.61404:61462]

B:BD[54.61404] → [54.61404:61462]

B:BD[54.61462] → [61.660:717]

∅:D[61.717] → [54.61546:61602]

B:BD[54.61546] → [54.61546:61602]

B:BD[54.61602] → [61.718:774]

∅:D[61.774] → [54.61685:61735]

B:BD[54.61685] → [54.61685:61735]

B:BD[54.61735] → [61.775:828]

∅:D[61.828] → [54.61815:61885]

B:BD[54.61815] → [54.61815:61885]

B:BD[54.61885] → [61.829:892]

∅:D[61.892] → [54.61975:62053]

B:BD[54.61975] → [54.61975:62053]

B:BD[54.62053] → [61.893:960]

∅:D[61.960] → [54.62147:62207]

B:BD[54.62147] → [54.62147:62207]

B:BD[54.62207] → [61.961:1019]

∅:D[61.1019] → [54.62292:62352]

B:BD[54.62292] → [54.62292:62352]

B:BD[54.62352] → [61.1020:1078]

∅:D[61.1078] → [54.62437:62616]

B:BD[54.62437] → [54.62437:62616]

B:BD[54.62616] → [62.25562:25737]

∅:D[62.25737] → [63.7637:7710]

B:BD[54.62787] → [63.7637:7710]

B:BD[63.7710] → [62.25738:25881]

B:BD[62.25881] → [17.0:122]

∅:D[17.122] → [54.62979:63032]

∅:D[64.458] → [54.62979:63032]

∅:D[39.22914] → [54.62979:63032]

∅:D[62.25963] → [54.62979:63032]

B:BD[54.62979] → [54.62979:63032]

B:BD[54.63032] → [61.1079:1133]

∅:D[61.1133] → [54.63113:63170]

B:BD[54.63113] → [54.63113:63170]

B:BD[54.63170] → [61.1134:1190]

∅:D[61.1190] → [54.63253:63316]

B:BD[54.63253] → [54.63253:63316]

B:BD[54.63316] → [61.1191:1250]

∅:D[61.1250] → [54.63402:63457]

B:BD[54.63402] → [54.63402:63457]

B:BD[54.63457] → [61.1251:1306]

∅:D[61.1306] → [39.22915:22966]

B:BD[54.63539] → [39.22915:22966]

B:BD[39.22966] → [61.1307:1360]

∅:D[61.1360] → [28.539904:539914]

∅:D[39.23046] → [28.539904:539914]

∅:D[54.63539] → [28.539904:539914]

B:BD[28.539904] → [28.539904:539914]

B:BD[28.539914] → [54.63540:63598]

B:BD[54.63598] → [61.1361:1418]

∅:D[61.1418] → [54.63682:63796]

B:BD[54.63682] → [54.63682:63796]

B:BD[54.63796] → [62.25964:26018]

B:BD[62.26018] → [2.0:126]

        use ::sanakirja::debug::Check;
        debug!("check: internal 0x{:x}", self.internal.db);
        self.internal.add_refs(&self.txn, refs).unwrap();
        debug!("check: external 0x{:x}", self.external.db);
        self.external.add_refs(&self.txn, refs).unwrap();
        debug!("check: inodes 0x{:x}", self.inodes.db);
        self.inodes.add_refs(&self.txn, refs).unwrap();
        debug!("check: revinodes 0x{:x}", self.revinodes.db);
        self.revinodes.add_refs(&self.txn, refs).unwrap();
        debug!("check: tree 0x{:x}", self.tree.db);
        self.tree.add_refs(&self.txn, refs).unwrap();
        debug!("check: revtree 0x{:x}", self.revtree.db);
        self.revtree.add_refs(&self.txn, refs).unwrap();
        debug!("check: revdep 0x{:x}", self.revdep.db);
        self.revdep.add_refs(&self.txn, refs).unwrap();
        debug!("check: dep 0x{:x}", self.dep.db);
        self.dep.add_refs(&self.txn, refs).unwrap();
        debug!("check: touched_files 0x{:x}", self.touched_files.db);
        self.touched_files.add_refs(&self.txn, refs).unwrap();
        debug!("check: rev_touched_files 0x{:x}", self.rev_touched_files.db);
        self.rev_touched_files.add_refs(&self.txn, refs).unwrap();
        debug!("check: partials 0x{:x}", self.partials.db);
        self.partials.add_refs(&self.txn, refs).unwrap();
        debug!("check: channels 0x{:x}", self.channels.db);
        self.channels.add_refs(&self.txn, refs).unwrap();
        for x in btree::iter(&self.txn, &self.channels, None).unwrap() {
            let (name, tup) = x.unwrap();
            debug!("check: channel name: {:?}", name.as_str());
            let graph: Db<Vertex<ChangeId>, SerializedEdge> = Db::from_page(tup.graph.into());
            let changes: Db<ChangeId, L64> = Db::from_page(tup.changes.into());
            let revchanges: UDb<L64, Pair<ChangeId, SerializedMerkle>> =
                UDb::from_page(tup.revchanges.into());
            let states: UDb<SerializedMerkle, L64> = UDb::from_page(tup.states.into());
            let tags: Db<L64, Pair<SerializedMerkle, SerializedMerkle>> =
                Db::from_page(tup.tags.into());
            debug!("check: graph 0x{:x}", graph.db);
            graph.add_refs(&self.txn, refs).unwrap();
            debug!("check: changes 0x{:x}", changes.db);
            changes.add_refs(&self.txn, refs).unwrap();
            debug!("check: revchanges 0x{:x}", revchanges.db);
            revchanges.add_refs(&self.txn, refs).unwrap();
            debug!("check: states 0x{:x}", states.db);
            states.add_refs(&self.txn, refs).unwrap();
            debug!("check: tags 0x{:x}", tags.db);
            tags.add_refs(&self.txn, refs).unwrap();
        }
        debug!("check: remotes 0x{:x}", self.remotes.db);
        self.remotes.add_refs(&self.txn, refs).unwrap();
        for x in btree::iter(&self.txn, &self.remotes, None).unwrap() {
            let (name, tup) = x.unwrap();
            debug!("check: remote name: {:?}", name);
            let remote: UDb<L64, Pair<SerializedHash, SerializedMerkle>> =
                UDb::from_page(tup.remote.into());

[61.330]

[2.126]

        unsafe {
            use ::sanakirja::debug::Check;
            debug!("check: internal 0x{:x}", self.internal.db);
            self.internal.add_refs(&self.txn, refs).unwrap();
            debug!("check: external 0x{:x}", self.external.db);
            self.external.add_refs(&self.txn, refs).unwrap();
            debug!("check: inodes 0x{:x}", self.inodes.db);
            self.inodes.add_refs(&self.txn, refs).unwrap();
            debug!("check: revinodes 0x{:x}", self.revinodes.db);
            self.revinodes.add_refs(&self.txn, refs).unwrap();
            debug!("check: tree 0x{:x}", self.tree.db);
            self.tree.add_refs(&self.txn, refs).unwrap();
            debug!("check: revtree 0x{:x}", self.revtree.db);
            self.revtree.add_refs(&self.txn, refs).unwrap();
            debug!("check: revdep 0x{:x}", self.revdep.db);
            self.revdep.add_refs(&self.txn, refs).unwrap();
            debug!("check: dep 0x{:x}", self.dep.db);
            self.dep.add_refs(&self.txn, refs).unwrap();
            debug!("check: touched_files 0x{:x}", self.touched_files.db);
            self.touched_files.add_refs(&self.txn, refs).unwrap();
            debug!("check: rev_touched_files 0x{:x}", self.rev_touched_files.db);
            self.rev_touched_files.add_refs(&self.txn, refs).unwrap();
            debug!("check: partials 0x{:x}", self.partials.db);
            self.partials.add_refs(&self.txn, refs).unwrap();
            debug!("check: channels 0x{:x}", self.channels.db);
            self.channels.add_refs(&self.txn, refs).unwrap();
            for x in btree::iter(&self.txn, &self.channels, None).unwrap() {
                let (name, tup) = x.unwrap();
                debug!("check: channel name: {:?}", name.as_str());
                let graph: Db<Vertex<ChangeId>, SerializedEdge> = Db::from_page(tup.graph.into());
                let changes: Db<ChangeId, L64> = Db::from_page(tup.changes.into());
                let revchanges: UDb<L64, Pair<ChangeId, SerializedMerkle>> =
                    UDb::from_page(tup.revchanges.into());
                let states: UDb<SerializedMerkle, L64> = UDb::from_page(tup.states.into());
                let tags: Db<L64, Pair<SerializedMerkle, SerializedMerkle>> =
                    Db::from_page(tup.tags.into());
                debug!("check: graph 0x{:x}", graph.db);
                graph.add_refs(&self.txn, refs).unwrap();
                debug!("check: changes 0x{:x}", changes.db);
                changes.add_refs(&self.txn, refs).unwrap();
                debug!("check: revchanges 0x{:x}", revchanges.db);
                revchanges.add_refs(&self.txn, refs).unwrap();
                debug!("check: states 0x{:x}", states.db);
                states.add_refs(&self.txn, refs).unwrap();
                debug!("check: tags 0x{:x}", tags.db);
                tags.add_refs(&self.txn, refs).unwrap();
            }
            debug!("check: remotes 0x{:x}", self.remotes.db);
            self.remotes.add_refs(&self.txn, refs).unwrap();
            for x in btree::iter(&self.txn, &self.remotes, None).unwrap() {
                let (name, tup) = x.unwrap();
                debug!("check: remote name: {:?}", name);
                let remote: UDb<L64, Pair<SerializedHash, SerializedMerkle>> =
                    UDb::from_page(tup.remote.into());

Replacement in libpijul/src/pristine/sanakirja.rs at line 372 [28.531056]

∅:D[65.111] → [62.26111:26279]

∅:D[2.127] → [62.26111:26279]

B:BD[62.26111] → [62.26111:26279]

B:BD[62.26279] → [7.0:124]

∅:D[66.108] → [54.64103:64158]

∅:D[7.124] → [54.64103:64158]

∅:D[62.26279] → [54.64103:64158]

B:BD[54.64103] → [54.64103:64158]

B:BD[54.64158] → [61.1419:1474]

∅:D[61.1474] → [54.64240:64289]

B:BD[54.64240] → [54.64240:64289]

B:BD[54.64289] → [61.1475:1527]

∅:D[61.1527] → [54.64368:64423]

B:BD[54.64368] → [54.64368:64423]

B:BD[54.64423] → [61.1528:1583]

B:BD[61.1583] → [66.109:213]

            let rev: UDb<SerializedHash, L64> = UDb::from_page(tup.rev.into());
            let states: UDb<SerializedMerkle, L64> = UDb::from_page(tup.states.into());
            let tags: UDb<L64, Pair<SerializedMerkle, SerializedMerkle>> =
                UDb::from_page(tup.tags.into());
            debug!("check: remote 0x{:x}", remote.db);
            remote.add_refs(&self.txn, refs).unwrap();
            debug!("check: rev 0x{:x}", rev.db);
            rev.add_refs(&self.txn, refs).unwrap();
            debug!("check: states 0x{:x}", states.db);
            states.add_refs(&self.txn, refs).unwrap();
            debug!("check: tags 0x{:x}", tags.db);
            tags.add_refs(&self.txn, refs).unwrap();

[2.127]

[28.541955]

                let rev: UDb<SerializedHash, L64> = UDb::from_page(tup.rev.into());
                let states: UDb<SerializedMerkle, L64> = UDb::from_page(tup.states.into());
                let tags: UDb<L64, Pair<SerializedMerkle, SerializedMerkle>> =
                    UDb::from_page(tup.tags.into());
                debug!("check: remote 0x{:x}", remote.db);
                remote.add_refs(&self.txn, refs).unwrap();
                debug!("check: rev 0x{:x}", rev.db);
                rev.add_refs(&self.txn, refs).unwrap();
                debug!("check: states 0x{:x}", states.db);
                states.add_refs(&self.txn, refs).unwrap();
                debug!("check: tags 0x{:x}", tags.db);
                tags.add_refs(&self.txn, refs).unwrap();
            }
            ::sanakirja::debug::add_free_refs(&self.txn, refs).unwrap();
            ::sanakirja::debug::check_free(&self.txn, &refs);

Deletion in libpijul/src/pristine/sanakirja.rs at line 388 [28.531056]
B:BD[28.541965] → [61.1584:1653]
∅:D[61.1653] → [54.64580:64638]
B:BD[54.64580] → [54.64580:64638]
```
        ::sanakirja::debug::add_free_refs(&self.txn, refs).unwrap();
        ::sanakirja::debug::check_free(&self.txn, &refs);
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 616 [28.531056]

∅:D[57.1967] → [59.62143:62226]

B:BD[54.68287] → [59.62143:62226]

    let mut k = match cursor.set(txn, &key, None) {
        Ok(Some((k, _))) => k,

[57.1967]

[59.62226]

    debug!("key {:?}", key);
    let (mut k, v) = match cursor.set(txn, &key, None) {
        Ok(Some((k, v))) => (k, v),

Replacement in libpijul/src/pristine/sanakirja.rs at line 620 [28.531056]

B:BD[59.62248] → [59.62248:62359]

            if let Some((k, _)) = cursor.prev(txn).map_err(|x| BlockError::Txn(x.into()))? {
                k

[59.62248]

[59.62359]

            if let Some((k, v)) = cursor.prev(txn).map_err(|x| BlockError::Txn(x.into()))? {
                (k, v)

Replacement in libpijul/src/pristine/sanakirja.rs at line 628 [28.531056]
B:BD[59.62535] → [59.62535:62586]
```
            debug!("find_block_end: BLOCK ERROR");
```
[59.62535]
[59.62586]
```
            debug!("find_block_end: BLOCK ERROR 0");
```
Insertion in libpijul/src/pristine/sanakirja.rs at line 632 [28.531056]
[67.36466]
[67.36581]
```
    debug!("cursor {:?} {:?}", k, v);
```
Insertion in libpijul/src/pristine/sanakirja.rs at line 1202 [28.531056]
[67.44210]
[54.76131]
```
        debug!("unsafe load channel");
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1375 [28.531056]

B:BD[62.26986] → [62.26986:27022]

B:BD[62.27022] → [68.98701:98762]

∅:D[59.63207] → [63.8251:8342]

∅:D[68.98762] → [63.8251:8342]

B:BD[28.550501] → [63.8251:8342]

B:BD[63.8342] → [62.27023:27084]

∅:D[62.27084] → [63.8411:8517]

B:BD[63.8411] → [63.8411:8517]

B:BD[63.8517] → [62.27085:27343]

B:BD[62.27343] → [69.3474:3539]

∅:D[69.3539] → [62.27343:27397]

B:BD[62.27343] → [62.27343:27397]

∅:D[62.27397] → [63.8718:9200]

B:BD[63.8718] → [63.8718:9200]

        let name = name.to_owned();
        match self.open_remotes.lock().entry(name.clone()) {
            Entry::Vacant(v) => match btree::get(&self.txn, &self.remotes, &name, None)? {
                Some((name_, remote)) if name == *name_ => {
                    debug!("load_remote: {:?} {:?}", name_, remote);
                    let r = Remote {
                        remote: UDb::from_page(remote.remote.into()),
                        rev: UDb::from_page(remote.rev.into()),
                        states: UDb::from_page(remote.states.into()),
                        id_rev: remote.id_rev.into(),
                        tags: Db::from_page(remote.tags.into()),
                        path: remote.path.to_owned(),
                    };
                    for x in btree::iter(&self.txn, &r.remote, None).unwrap() {
                        debug!("remote -> {:?}", x);
                    }
                    for x in btree::iter(&self.txn, &r.rev, None).unwrap() {
                        debug!("rev -> {:?}", x);
                    }
                    for x in btree::iter(&self.txn, &r.states, None).unwrap() {
                        debug!("states -> {:?}", x);
                    }

[62.26986]

[54.78508]

        unsafe {
            let name = name.to_owned();
            match self.open_remotes.lock().entry(name.clone()) {
                Entry::Vacant(v) => match btree::get(&self.txn, &self.remotes, &name, None)? {
                    Some((name_, remote)) if name == *name_ => {
                        debug!("load_remote: {:?} {:?}", name_, remote);
                        let r = Remote {
                            remote: UDb::from_page(remote.remote.into()),
                            rev: UDb::from_page(remote.rev.into()),
                            states: UDb::from_page(remote.states.into()),
                            id_rev: remote.id_rev.into(),
                            tags: Db::from_page(remote.tags.into()),
                            path: remote.path.to_owned(),
                        };
                        for x in btree::iter(&self.txn, &r.remote, None).unwrap() {
                            debug!("remote -> {:?}", x);
                        }
                        for x in btree::iter(&self.txn, &r.rev, None).unwrap() {
                            debug!("rev -> {:?}", x);
                        }
                        for x in btree::iter(&self.txn, &r.states, None).unwrap() {
                            debug!("states -> {:?}", x);
                        }

Replacement in libpijul/src/pristine/sanakirja.rs at line 1399 [28.531056]

B:BD[54.78509] → [63.9201:9320]

                    for x in self.iter_remote(&r.remote, 0).unwrap() {
                        debug!("ITER {:?}", x);

[54.78509]

[54.78894]

                        for x in self.iter_remote(&r.remote, 0).unwrap() {
                            debug!("ITER {:?}", x);
                        }
                        let r = RemoteRef {
                            db: Arc::new(Mutex::new(r)),
                            id: name,
                        };
                        Ok(Some(v.insert(r).clone()))

Replacement in libpijul/src/pristine/sanakirja.rs at line 1409 [28.531056]

B:BD[54.78916] → [63.9321:9362]

B:BD[63.9362] → [59.63208:63261]

B:BD[59.63261] → [62.27398:27432]

∅:D[62.27432] → [63.9460:9533]

B:BD[63.9460] → [63.9460:9533]

∅:D[63.9533] → [28.551161:551179]

∅:D[70.47633] → [28.551161:551179]

∅:D[54.78957] → [28.551161:551179]

B:BD[28.551161] → [28.551161:551179]

B:BD[28.551179] → [63.9534:9587]

∅:D[63.9587] → [67.45322:45387]

B:BD[28.551193] → [67.45322:45387]


                    let r = RemoteRef {
                        db: Arc::new(Mutex::new(r)),
                        id: name,
                    };
                    Ok(Some(v.insert(r).clone()))
                }
                _ => return Ok(None),
            },
            Entry::Occupied(occ) => Ok(Some(occ.get().clone())),

[54.78916]

[28.551230]

                    _ => return Ok(None),
                },
                Entry::Occupied(occ) => Ok(Some(occ.get().clone())),
            }

Replacement in libpijul/src/pristine/sanakirja.rs at line 1508 [28.531056]

B:BD[70.48638] → [62.28068:28104]

B:BD[62.28104] → [68.98763:98824]

∅:D[59.63332] → [63.9588:9679]

∅:D[68.98824] → [63.9588:9679]

B:BD[28.555427] → [63.9588:9679]

B:BD[63.9679] → [62.28105:28166]

∅:D[62.28166] → [63.9748:9788]

B:BD[63.9748] → [63.9748:9788]

B:BD[63.9788] → [59.63333:63390]

B:BD[59.63390] → [62.28167:28441]

B:BD[62.28441] → [69.3540:3609]

∅:D[69.3609] → [62.28441:28499]

B:BD[62.28441] → [62.28441:28499]

∅:D[62.28499] → [63.10059:10088]

B:BD[63.10059] → [63.10059:10088]

B:BD[63.10088] → [62.28500:28534]

∅:D[62.28534] → [63.10132:10188]

B:BD[63.10132] → [63.10132:10188]

∅:D[63.10188] → [28.556087:556105]

∅:D[70.48698] → [28.556087:556105]

∅:D[54.81384] → [28.556087:556105]

B:BD[28.556087] → [28.556087:556105]

B:BD[28.556105] → [63.10189:10242]

∅:D[63.10242] → [28.556119:556156]

B:BD[28.556119] → [28.556119:556156]

        let name = name.to_owned();
        match self.open_remotes.lock().entry(name.clone()) {
            Entry::Vacant(v) => match btree::get(&self.txn, &self.remotes, &name, None)? {
                Some((name_, remote)) if *name_ == name => {
                    let r = RemoteRef {
                        db: Arc::new(Mutex::new(Remote {
                            remote: UDb::from_page(remote.remote.into()),
                            rev: UDb::from_page(remote.rev.into()),
                            states: UDb::from_page(remote.states.into()),
                            id_rev: remote.id_rev.into(),
                            tags: Db::from_page(remote.tags.into()),
                            path: remote.path.to_owned(),
                        })),
                        id: name,
                    };
                    v.insert(r);
                }
                _ => return Ok(None),
            },
            Entry::Occupied(_) => {}

[70.48638]

[28.556156]

        unsafe {
            let name = name.to_owned();
            match self.open_remotes.lock().entry(name.clone()) {
                Entry::Vacant(v) => match btree::get(&self.txn, &self.remotes, &name, None)? {
                    Some((name_, remote)) if *name_ == name => {
                        let r = RemoteRef {
                            db: Arc::new(Mutex::new(Remote {
                                remote: UDb::from_page(remote.remote.into()),
                                rev: UDb::from_page(remote.rev.into()),
                                states: UDb::from_page(remote.states.into()),
                                id_rev: remote.id_rev.into(),
                                tags: Db::from_page(remote.tags.into()),
                                path: remote.path.to_owned(),
                            })),
                            id: name,
                        };
                        v.insert(r);
                    }
                    _ => return Ok(None),
                },
                Entry::Occupied(_) => {}
            }
            Ok(self.open_remotes.lock().get(&name).cloned())

Deletion in libpijul/src/pristine/sanakirja.rs at line 1532 [28.531056]
B:BD[28.556166] → [68.98825:98882]
```
        Ok(self.open_remotes.lock().get(&name).cloned())
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1992 [28.531056]

B:BD[70.52835] → [54.86749:86818]

∅:D[54.86818] → [28.563252:563283]

B:BD[28.563252] → [28.563252:563283]

B:BD[28.563283] → [68.99121:99196]

∅:D[67.48487] → [28.563351:563385]

∅:D[59.66689] → [28.563351:563385]

∅:D[68.99196] → [28.563351:563385]

B:BD[28.563351] → [28.563351:563385]

B:BD[28.563385] → [63.10301:10385]

B:BD[63.10385] → [71.0:79]

B:BD[71.79] → [59.66690:66748]

B:BD[59.66748] → [62.28535:28817]

B:BD[62.28817] → [53.4762:4826]

∅:D[53.4826] → [62.28882:29054]

B:BD[62.28882] → [62.28882:29054]

∅:D[39.25888] → [71.465:513]

∅:D[62.29054] → [71.465:513]

B:BD[71.465] → [71.465:513]

B:BD[71.571] → [71.571:623]

∅:D[71.623] → [63.11102:11175]

B:BD[63.11102] → [63.11102:11175]

        let name = crate::small_string::SmallString::from_str(name);
        let mut commit = None;
        let result = match self.open_channels.lock().entry(name.clone()) {
            Entry::Vacant(v) => {
                let r = match btree::get(&self.txn, &self.channels, &name, None)? {
                    Some((name_, b)) if name_ == name.as_ref() => ChannelRef {
                        r: Arc::new(RwLock::new(Channel {
                            graph: Db::from_page(b.graph.into()),
                            changes: Db::from_page(b.changes.into()),
                            revchanges: UDb::from_page(b.revchanges.into()),
                            states: UDb::from_page(b.states.into()),
                            tags: Db::from_page(b.tags.into()),
                            apply_counter: b.apply_counter.into(),
                            last_modified: b.last_modified.into(),
                            id: b.id,
                            name: name.clone(),
                        })),
                    },
                    _ => {
                        let br = ChannelRef {

[70.52835]

[59.66749]

        unsafe {
            let name = crate::small_string::SmallString::from_str(name);
            let mut commit = None;
            let result = match self.open_channels.lock().entry(name.clone()) {
                Entry::Vacant(v) => {
                    let r = match btree::get(&self.txn, &self.channels, &name, None)? {
                        Some((name_, b)) if name_ == name.as_ref() => ChannelRef {

Replacement in libpijul/src/pristine/sanakirja.rs at line 2000 [28.531056]

∅:D[59.66811] → [63.11237:11541]

B:BD[63.11237] → [63.11237:11541]

B:BD[63.11541] → [39.25889:25962]

B:BD[39.25962] → [62.29055:29509]

∅:D[39.25962] → [63.11541:11591]

∅:D[62.29509] → [63.11541:11591]

B:BD[63.11541] → [63.11541:11591]

B:BD[63.11591] → [39.25963:26013]

                                graph: btree::create_db_(&mut self.txn)?,
                                changes: btree::create_db_(&mut self.txn)?,
                                revchanges: btree::create_db_(&mut self.txn)?,
                                states: btree::create_db_(&mut self.txn)?,
                                tags: btree::create_db_(&mut self.txn)?,
                                id: {
                                    let mut rng = rand::thread_rng();
                                    use rand::Rng;
                                    let mut x = RemoteId([0; 16]);
                                    for x in x.0.iter_mut() {
                                        *x = rng.gen()
                                    }
                                    x
                                },
                                apply_counter: 0,
                                last_modified: 0,

[59.66811]

[63.11591]

                                graph: Db::from_page(b.graph.into()),
                                changes: Db::from_page(b.changes.into()),
                                revchanges: UDb::from_page(b.revchanges.into()),
                                states: UDb::from_page(b.states.into()),
                                tags: Db::from_page(b.tags.into()),
                                apply_counter: b.apply_counter.into(),
                                last_modified: b.last_modified.into(),
                                id: b.id,

Replacement in libpijul/src/pristine/sanakirja.rs at line 2010 [28.531056]

B:BD[63.11726] → [63.11726:11872]

∅:D[63.11872] → [67.48488:48524]

B:BD[28.564869] → [67.48488:48524]

                        };
                        commit = Some(br.clone());
                        br
                    }
                };
                v.insert(r).clone()

[63.11726]

[28.564898]

                        },
                        _ => {
                            let br = ChannelRef {
                                r: Arc::new(RwLock::new(Channel {
                                    graph: btree::create_db_(&mut self.txn)?,
                                    changes: btree::create_db_(&mut self.txn)?,
                                    revchanges: btree::create_db_(&mut self.txn)?,
                                    states: btree::create_db_(&mut self.txn)?,
                                    tags: btree::create_db_(&mut self.txn)?,
                                    id: {
                                        let mut rng = rand::thread_rng();
                                        use rand::Rng;
                                        let mut x = RemoteId([0; 16]);
                                        for x in x.0.iter_mut() {
                                            *x = rng.gen()
                                        }
                                        x
                                    },
                                    apply_counter: 0,
                                    last_modified: 0,
                                    name: name.clone(),
                                })),
                            };
                            commit = Some(br.clone());
                            br
                        }
                    };
                    v.insert(r).clone()
                }
                Entry::Occupied(occ) => occ.get().clone(),
            };
            if let Some(commit) = commit {
                self.put_channel(commit)?;

Replacement in libpijul/src/pristine/sanakirja.rs at line 2044 [28.531056]
B:BD[28.564912] → [67.48525:48591]
∅:D[67.48591] → [28.564959:564998]
B:BD[28.564959] → [28.564959:564998]
B:BD[28.564998] → [72.317:356]
```
            Entry::Occupied(occ) => occ.get().clone(),
        };
        if let Some(commit) = commit {
            self.put_channel(commit)?;
```
[28.564912]
[28.565045]
```
            Ok(result)
```
Deletion in libpijul/src/pristine/sanakirja.rs at line 2046 [28.531056]
B:BD[28.565055] → [67.48592:48611]
```
        Ok(result)
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 2128 [28.531056]

B:BD[73.169] → [74.0:68]

∅:D[74.68] → [73.169:218]

B:BD[73.169] → [73.169:218]

B:BD[73.218] → [68.99538:99625]

∅:D[68.99625] → [59.67401:67454]

B:BD[59.67401] → [59.67401:67454]

∅:D[59.67454] → [75.3664:3783]

B:BD[73.363] → [75.3664:3783]

B:BD[75.3783] → [68.99626:99657]

∅:D[59.67512] → [73.476:627]

∅:D[68.99657] → [73.476:627]

B:BD[73.476] → [73.476:627]

B:BD[73.627] → [76.0:30]

∅:D[76.30] → [73.627:780]

B:BD[73.627] → [73.627:780]

        debug!(target: "drop_channel", "drop channel {:?}", name0);
        let name = SmallString::from_str(name0);
        let channel = if let Some(channel) = self.open_channels.lock().remove(&name) {
            let channel = Arc::try_unwrap(channel.r)
                .map_err(|_| SanakirjaError::ChannelRc {
                    c: name0.to_string(),
                })?
                .into_inner();
            Some((
                channel.graph,
                channel.changes,
                channel.revchanges,
                channel.states,
                channel.tags,
            ))
        } else if let Some((name_, chan)) = btree::get(&self.txn, &self.channels, &name, None)? {
            if name_ == name.as_ref() {

[73.169]

[73.780]

        unsafe {
            debug!(target: "drop_channel", "drop channel {:?}", name0);
            let name = SmallString::from_str(name0);
            let channel = if let Some(channel) = self.open_channels.lock().remove(&name) {
                let channel = Arc::try_unwrap(channel.r)
                    .map_err(|_| SanakirjaError::ChannelRc {
                        c: name0.to_string(),
                    })?
                    .into_inner();

Replacement in libpijul/src/pristine/sanakirja.rs at line 2138 [28.531056]

B:BD[73.803] → [62.29893:30119]

B:BD[62.30119] → [53.4827:4880]

                    Db::from_page(chan.graph.into()),
                    Db::from_page(chan.changes.into()),
                    UDb::from_page(chan.revchanges.into()),
                    UDb::from_page(chan.states.into()),
                    Db::from_page(chan.tags.into()),

[73.803]

[73.1017]

                    channel.graph,
                    channel.changes,
                    channel.revchanges,
                    channel.states,
                    channel.tags,

Insertion in libpijul/src/pristine/sanakirja.rs at line 2144 [28.531056]

[73.1036]

            } else if let Some((name_, chan)) = btree::get(&self.txn, &self.channels, &name, None)?
            {
                if name_ == name.as_ref() {
                    Some((
                        Db::from_page(chan.graph.into()),
                        Db::from_page(chan.changes.into()),
                        UDb::from_page(chan.revchanges.into()),
                        UDb::from_page(chan.states.into()),
                        Db::from_page(chan.tags.into()),
                    ))
                } else {
                    None
                }

Replacement in libpijul/src/pristine/sanakirja.rs at line 2159 [28.531056]

B:BD[73.1078] → [73.1078:1137]

B:BD[73.1137] → [77.0:69]

B:BD[77.69] → [76.86:135]

∅:D[76.135] → [78.0:151]

B:BD[73.1183] → [78.0:151]

B:BD[76.190] → [68.99658:99702]

B:BD[68.99702] → [5.442:501]

∅:D[5.501] → [79.2052:2243]

∅:D[68.99702] → [79.2052:2243]

B:BD[78.441] → [79.2052:2243]

B:BD[79.2243] → [74.740:926]

∅:D[74.926] → [79.2243:2281]

B:BD[79.2243] → [79.2243:2281]

            }
        } else {
            None
        };
        btree::del(&mut self.txn, &mut self.channels, &name, None)?;
        if let Some((a, b, c, d, e)) = channel {
            let mut unused_changes = Vec::new();
            'outer: for x in btree::rev_iter(&self.txn, &c, None)? {
                let (_, p) = x?;
                    let chan = chan.read();
                    assert_ne!(chan.name.as_str(), name0);
                    if self
                        .channel_has_state(&chan.states, &p.b)
                        .map_err(|e| e.0)?
                        .is_some()
                    {
                        // This other channel is in the same state as
                        // our dropped channel is, so all subsequent
                        // patches are in use.
                        break 'outer;

[73.1078]

[78.574]

            };
            btree::del(&mut self.txn, &mut self.channels, &name, None)?;
            if let Some((a, b, c, d, e)) = channel {
                let mut unused_changes = Vec::new();
                'outer: for x in btree::rev_iter(&self.txn, &c, None)? {
                    let (_, p) = x?;
                    debug!(target: "drop_channel", "testing unused change: {:?}", p);
                    for chan in self.channels("").map_err(|e| e.0)? {
                        debug!(target: "drop_channel", "channel: {:?}", name);
                        let chan = chan.read();
                        assert_ne!(chan.name.as_str(), name0);
                        if self
                            .channel_has_state(&chan.states, &p.b)
                            .map_err(|e| e.0)?
                            .is_some()
                        {
                            // This other channel is in the same state as
                            // our dropped channel is, so all subsequent
                            // patches are in use.
                            break 'outer;
                        }
                        if self
                            .get_changeset(&chan.changes, &p.a)
                            .map_err(|e| e.0)?
                            .is_some()
                        {
                            // This channel has a patch, move on.
                            continue 'outer;
                        }

Replacement in libpijul/src/pristine/sanakirja.rs at line 2189 [28.531056]

B:BD[78.596] → [79.2282:2470]

B:BD[79.2470] → [74.927:989]

∅:D[74.989] → [79.2470:2511]

B:BD[79.2470] → [79.2470:2511]

                    if self
                        .get_changeset(&chan.changes, &p.a)
                        .map_err(|e| e.0)?
                        .is_some()
                    {
                        // This channel has a patch, move on.
                        continue 'outer;

[78.596]

[78.729]


                    debug!(target: "drop_channel", "actually unused: {:?}", p);
                    unused_changes.push(p.a);
                }
                let mut deps = Vec::new();
                for ch in unused_changes.iter() {
                    for x in btree::iter(&self.txn, &self.dep, Some((ch, None)))? {
                        let (k, v) = x?;
                        if k > ch {
                            break;
                        }
                        deps.push((*k, *v));

Replacement in libpijul/src/pristine/sanakirja.rs at line 2202 [28.531056]

B:BD[78.751] → [78.751:769]

B:BD[78.769] → [74.990:1067]

∅:D[74.1067] → [78.769:825]

B:BD[78.769] → [78.769:825]

B:BD[78.825] → [77.70:109]

∅:D[77.109] → [78.825:871]

B:BD[78.825] → [78.825:871]

B:BD[78.871] → [77.110:259]

B:BD[77.259] → [79.2512:2543]

                }
                debug!(target: "drop_channel", "actually unused: {:?}", p);
                unused_changes.push(p.a);
            }
            let mut deps = Vec::new();
            for ch in unused_changes.iter() {
                for x in btree::iter(&self.txn, &self.dep, Some((ch, None)))? {
                    let (k, v) = x?;
                    if k > ch {
                        break;

[78.751]

[77.289]

                    for (k, v) in deps.drain(..) {
                        debug!(target: "drop_channel", "deleting from revdep: {:?} {:?}", k, v);
                        btree::del(&mut self.txn, &mut self.dep, &k, Some(&v))?;
                        btree::del(&mut self.txn, &mut self.revdep, &v, Some(&k))?;

Deletion in libpijul/src/pristine/sanakirja.rs at line 2207 [28.531056]
B:BD[77.311] → [77.311:352]
```
                    deps.push((*k, *v));
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 2208 [28.531056]

B:BD[77.370] → [77.370:417]

B:BD[77.417] → [74.1068:1238]

∅:D[74.1238] → [77.497:595]

B:BD[77.497] → [77.497:595]

                for (k, v) in deps.drain(..) {
                    debug!(target: "drop_channel", "deleting from revdep: {:?} {:?}", k, v);
                    btree::del(&mut self.txn, &mut self.dep, &k, Some(&v))?;
                    btree::del(&mut self.txn, &mut self.revdep, &v, Some(&k))?;
                }

[77.370]

[78.1028]

                btree::drop(&mut self.txn, a)?;
                btree::drop(&mut self.txn, b)?;
                btree::drop(&mut self.txn, c)?;
                btree::drop(&mut self.txn, d)?;
                btree::drop(&mut self.txn, e)?;
                Ok(true)
            } else {
                Ok(false)

Deletion in libpijul/src/pristine/sanakirja.rs at line 2217 [28.531056]

∅:D[78.1042] → [73.1183:1359]

B:BD[73.1183] → [73.1183:1359]

B:BD[73.1359] → [76.191:235]

∅:D[76.235] → [77.596:656]

B:BD[73.1359] → [77.596:656]

            btree::drop(&mut self.txn, a)?;
            btree::drop(&mut self.txn, b)?;
            btree::drop(&mut self.txn, c)?;
            btree::drop(&mut self.txn, d)?;
            btree::drop(&mut self.txn, e)?;
            Ok(true)
        } else {
            Ok(false)

Replacement in libpijul/src/pristine/sanakirja.rs at line 2225 [28.531056]

∅:D[62.30318] → [28.568157:568188]

∅:D[54.90802] → [28.568157:568188]

B:BD[28.568157] → [28.568157:568188]

B:BD[28.568188] → [68.99703:99754]

∅:D[62.30379] → [28.568255:568289]

∅:D[59.67583] → [28.568255:568289]

∅:D[68.99754] → [28.568255:568289]

B:BD[28.568255] → [28.568255:568289]

B:BD[28.568289] → [62.30380:30534]

∅:D[62.30534] → [59.67584:67641]

B:BD[63.12543] → [59.67584:67641]

B:BD[59.67641] → [62.30535:30809]

B:BD[62.30809] → [69.3746:3815]

∅:D[69.3815] → [62.30809:30872]

B:BD[62.30809] → [62.30809:30872]

∅:D[62.30872] → [63.12814:12843]

B:BD[63.12814] → [63.12814:12843]

B:BD[63.12843] → [62.30873:30901]

∅:D[62.30901] → [63.12887:12982]

B:BD[63.12887] → [63.12887:12982]

        let mut commit = None;
        match self.open_remotes.lock().entry(id) {
            Entry::Vacant(v) => {
                let r = match btree::get(&self.txn, &self.remotes, &id, None)? {
                    Some((name_, remote)) if *name_ == id => RemoteRef {
                        db: Arc::new(Mutex::new(Remote {
                            remote: UDb::from_page(remote.remote.into()),
                            rev: UDb::from_page(remote.rev.into()),
                            states: UDb::from_page(remote.states.into()),
                            id_rev: remote.id_rev.into(),
                            tags: Db::from_page(remote.tags.into()),
                            path: SmallString::from_str(path),
                        })),
                        id,
                    },
                    _ => {
                        let br = RemoteRef {

[62.30318]

[59.67642]

        unsafe {
            let mut commit = None;
            match self.open_remotes.lock().entry(id) {
                Entry::Vacant(v) => {
                    let r = match btree::get(&self.txn, &self.remotes, &id, None)? {
                        Some((name_, remote)) if *name_ == id => RemoteRef {

Replacement in libpijul/src/pristine/sanakirja.rs at line 2232 [28.531056]

∅:D[59.67703] → [63.13044:13266]

B:BD[63.13044] → [63.13044:13266]

B:BD[63.13266] → [62.30902:30955]

B:BD[62.30955] → [69.3816:3888]

                                remote: btree::create_db_(&mut self.txn)?,
                                rev: btree::create_db_(&mut self.txn)?,
                                states: btree::create_db_(&mut self.txn)?,
                                id_rev: 0u64.into(),
                                tags: btree::create_db(&mut self.txn)?,

[59.67703]

[62.30955]

                                remote: UDb::from_page(remote.remote.into()),
                                rev: UDb::from_page(remote.rev.into()),
                                states: UDb::from_page(remote.states.into()),
                                id_rev: remote.id_rev.into(),
                                tags: Db::from_page(remote.tags.into()),

Replacement in libpijul/src/pristine/sanakirja.rs at line 2240 [28.531056]

∅:D[62.31055] → [63.13347:13493]

B:BD[63.13347] → [63.13347:13493]

∅:D[63.13493] → [28.569306:569335]

B:BD[28.569306] → [28.569306:569335]

                        };
                        commit = Some(br.clone());
                        br
                    }
                };
                v.insert(r);

[62.31055]

[28.569335]

                        },
                        _ => {
                            let br = RemoteRef {
                                db: Arc::new(Mutex::new(Remote {
                                    remote: btree::create_db_(&mut self.txn)?,
                                    rev: btree::create_db_(&mut self.txn)?,
                                    states: btree::create_db_(&mut self.txn)?,
                                    id_rev: 0u64.into(),
                                    tags: btree::create_db(&mut self.txn)?,
                                    path: SmallString::from_str(path),
                                })),
                                id,
                            };
                            commit = Some(br.clone());
                            br
                        }
                    };
                    v.insert(r);
                }
                Entry::Occupied(_) => {}

Replacement in libpijul/src/pristine/sanakirja.rs at line 2261 [28.531056]

B:BD[28.569349] → [28.569349:569386]

            Entry::Occupied(_) => {}

[28.569349]

[28.569386]

            if let Some(commit) = commit {
                self.put_remotes(commit)?;
            }
            Ok(self.open_remotes.lock().get(&id).unwrap().clone())

Deletion in libpijul/src/pristine/sanakirja.rs at line 2266 [28.531056]
B:BD[28.569396] → [28.569396:569435]
B:BD[28.569435] → [80.2750:2789]
∅:D[80.2789] → [28.569482:569492]
B:BD[28.569482] → [28.569482:569492]
B:BD[28.569492] → [68.99755:99818]
```
        if let Some(commit) = commit {
            self.put_remotes(commit)?;
        }
        Ok(self.open_remotes.lock().get(&id).unwrap().clone())
```

Deletion in libpijul/src/pristine/sanakirja.rs at line 2325 [28.531056]

∅:D[61.2151] → [54.92330:92526]

∅:D[59.68505] → [54.92330:92526]

B:BD[28.571127] → [54.92330:92526]

        self.txn.set_root(Root::Tree as usize, self.tree.db);
        self.txn.set_root(Root::RevTree as usize, self.revtree.db);
        self.txn.set_root(Root::Inodes as usize, self.inodes.db);

Replacement in libpijul/src/pristine/sanakirja.rs at line 2326 [28.531056]

B:BD[63.13511] → [63.13511:13579]

∅:D[63.13579] → [54.92598:92942]

B:BD[54.92598] → [54.92598:92942]

            .set_root(Root::RevInodes as usize, self.revinodes.db);
        self.txn.set_root(Root::Internal as usize, self.internal.db);
        self.txn.set_root(Root::External as usize, self.external.db);
        self.txn.set_root(Root::RevDep as usize, self.revdep.db);
        self.txn.set_root(Root::Channels as usize, self.channels.db);
        self.txn.set_root(Root::Remotes as usize, self.remotes.db);

[63.13511]

[28.571712]

            .set_root(Root::Tree as usize, u64::from(self.tree.db).into());
        self.txn
            .set_root(Root::RevTree as usize, u64::from(self.revtree.db).into());
        self.txn
            .set_root(Root::Inodes as usize, u64::from(self.inodes.db).into());
        self.txn
            .set_root(Root::RevInodes as usize, self.revinodes.db.into());
        self.txn
            .set_root(Root::Internal as usize, self.internal.db.into());
        self.txn
            .set_root(Root::External as usize, self.external.db.into());
        self.txn
            .set_root(Root::RevDep as usize, self.revdep.db.into());
        self.txn
            .set_root(Root::Channels as usize, self.channels.db.into());

Replacement in libpijul/src/pristine/sanakirja.rs at line 2342 [28.531056]

B:BD[28.571729] → [54.92943:93078]

            .set_root(Root::TouchedFiles as usize, self.touched_files.db);
        self.txn.set_root(Root::Dep as usize, self.dep.db);

[28.571729]

[28.571858]

            .set_root(Root::Remotes as usize, self.remotes.db.into());

Insertion in libpijul/src/pristine/sanakirja.rs at line 2344 [28.531056]

[28.571875]

[28.572022]

            .set_root(Root::TouchedFiles as usize, self.touched_files.db.into());
        self.txn.set_root(Root::Dep as usize, self.dep.db.into());
        self.txn.set_root(
            Root::RevTouchedFiles as usize,
            self.rev_touched_files.db.into(),
        );
        self.txn
            .set_root(Root::Partials as usize, self.partials.db.into());

Replacement in libpijul/src/pristine/sanakirja.rs at line 2364 [28.531056]

∅:D[67.48706] → [28.572161:572209]

∅:D[70.53620] → [28.572161:572209]

B:BD[28.572161] → [28.572161:572209]

B:BD[28.572209] → [54.93232:93300]

B:BD[54.93300] → [81.132:192]

∅:D[81.192] → [63.13580:13648]

B:BD[54.93384] → [63.13580:13648]

∅:D[63.13648] → [54.93452:93486]

B:BD[54.93452] → [54.93452:93486]

B:BD[54.93486] → [62.31606:31856]

B:BD[62.31856] → [53.4881:4937]

∅:D[53.4937] → [62.31913:32061]

B:BD[62.31913] → [62.31913:32061]

∅:D[39.26316] → [54.93824:93870]

∅:D[62.32061] → [54.93824:93870]

B:BD[54.93824] → [54.93824:93870]

        let name = SmallString::from_str(name);
        match btree::get(&self.txn, &self.channels, &name, None)? {
            Some((name_, c)) if name.as_ref() == name_ => {
                debug!("load_const_channel = {:?} {:?}", name_, c);
                Ok(Some(Channel {
                    graph: Db::from_page(c.graph.into()),
                    changes: Db::from_page(c.changes.into()),
                    revchanges: UDb::from_page(c.revchanges.into()),
                    states: UDb::from_page(c.states.into()),
                    tags: Db::from_page(c.tags.into()),
                    apply_counter: c.apply_counter.into(),
                    last_modified: c.last_modified.into(),
                    id: c.id,
                    name,
                }))

[67.48706]

[54.93870]

        unsafe {
            let name = SmallString::from_str(name);
            match btree::get(&self.txn, &self.channels, &name, None)? {
                Some((name_, c)) if name.as_ref() == name_ => {
                    debug!("load_const_channel = {:?} {:?}", name_, c);
                    Ok(Some(Channel {
                        graph: Db::from_page(c.graph.into()),
                        changes: Db::from_page(c.changes.into()),
                        revchanges: UDb::from_page(c.revchanges.into()),
                        states: UDb::from_page(c.states.into()),
                        tags: Db::from_page(c.tags.into()),
                        apply_counter: c.apply_counter.into(),
                        last_modified: c.last_modified.into(),
                        id: c.id,
                        name,
                    }))
                }
                _ => Ok(None),

Deletion in libpijul/src/pristine/sanakirja.rs at line 2383 [28.531056]
B:BD[54.93884] → [63.13649:13676]
```
            _ => Ok(None),
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 2402 [28.531056]

B:BD[62.32099] → [62.32099:32333]

            graph: channel.graph.db.into(),
            changes: channel.changes.db.into(),
            revchanges: channel.revchanges.db.into(),
            states: channel.states.db.into(),
            tags: channel.tags.db.into(),

[62.32099]

[62.32333]

            graph: u64::from(channel.graph.db).into(),
            changes: u64::from(channel.changes.db).into(),
            revchanges: u64::from(channel.revchanges.db).into(),
            states: u64::from(channel.states.db).into(),
            tags: u64::from(channel.tags.db).into(),

Replacement in libpijul/src/pristine/sanakirja.rs at line 2426 [28.531056]

B:BD[62.32678] → [62.32678:32795]

            _remote: r.remote.db.into(),
            _rev: r.rev.db.into(),
            _states: r.states.db.into(),

[62.32678]

[62.32795]

            _remote: u64::from(r.remote.db).into(),
            _rev: u64::from(r.rev.db).into(),
            _states: u64::from(r.states.db).into(),

Replacement in libpijul/src/pristine/sanakirja.rs at line 2430 [28.531056]
B:BD[62.32833] → [27.43445:43482]
```
            _tags: r.tags.db.into(),
```
[62.32833]
[62.32833]
```
            _tags: u64::from(r.tags.db).into(),
```
Deletion in libpijul/src/pristine/sanakirja.rs at line 2446 [28.531056]
B:BD[28.576098] → [54.94946:94965]
B:BD[54.94965] → [82.706:748]
∅:D[82.748] → [28.576850:576851]
∅:D[61.2428] → [28.576850:576851]
∅:D[54.94965] → [28.576850:576851]
B:BD[28.576850] → [28.576850:576851]
```
direct_repr!(L64);
impl ::sanakirja::debug::Check for L64 {}
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 2480 [28.531056]
B:BD[28.580114] → [54.95644:95693]
```
    unsafe fn write_to_page(&self, p: *mut u8) {
```
[28.580114]
[54.95693]
```
    unsafe fn write_to_page<T: AllocPage>(&self, t: &mut T, p: *mut u8) {
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 2482 [28.531056]
B:BD[54.95745] → [54.95745:95791]
```
        self.basename.write_to_page(p.add(8))
```
[54.95745]
[28.580261]
```
        self.basename.write_to_page(t, p.add(8))
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 2559 [28.531056]

B:BD[28.584822] → [54.97617:97699]

    unsafe fn write_to_page(&self, p: *mut u8) {
        self.a.write_to_page(p);

[28.584822]

[54.97699]

    unsafe fn write_to_page<T: sanakirja::AllocPage>(&self, t: &mut T, p: *mut u8) {
        self.a.write_to_page(t, p);

Replacement in libpijul/src/pristine/sanakirja.rs at line 2562 [28.531056]
B:BD[54.97769] → [54.97769:97811]
```
        self.b.write_to_page(p.add(off));
```
[54.97769]
[28.584945]
```
        self.b.write_to_page(t, p.add(off));
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 2594 [28.531056]

B:BD[62.33816] → [62.33816:33865]

    unsafe fn write_to_page(&self, p: *mut u8) {

[62.33816]

[62.33865]

    unsafe fn write_to_page<T: sanakirja::AllocPage>(&self, _: &mut T, p: *mut u8) {

Deletion in libpijul/src/pristine/sanakirja.rs at line 2636 [28.531056]

B:BD[28.571875] → [54.93079:93231]

B:BD[78.151] → [74.69:151]

B:BD[74.151] → [5.375:441]

∅:D[5.441] → [74.664:739]

B:BD[74.664] → [74.664:739]

            .set_root(Root::RevTouchedFiles as usize, self.rev_touched_files.db);
        self.txn.set_root(Root::Partials as usize, self.partials.db);
                debug!(target: "drop_channel", "testing unused change: {:?}", p);
                for chan in self.channels("").map_err(|e| e.0)? {
                    debug!(target: "drop_channel", "channel: {:?}", name);

Solving an order conflict in libpijul/src/pristine/sanakirja.rs at line 2636 [28.531056]
[82.1439]
Insertion in libpijul/src/pristine/mod.rs at line 4 [28.586748]
[59.68821]
[68.100436]
```
pub use ::sanakirja::L64;
```

Deletion in libpijul/src/pristine/mod.rs at line 25 [28.586748]

B:BD[54.98674] → [54.98674:99750]


#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct L64(pub u64);
impl From<usize> for L64 {
    fn from(u: usize) -> Self {
        L64((u as u64).to_le())
    }
}
impl From<u64> for L64 {
    fn from(u: u64) -> Self {
        L64(u.to_le())
    }
}
impl From<L64> for u64 {
    fn from(u: L64) -> Self {
        u64::from_le(u.0)
    }
}
impl From<L64> for usize {
    fn from(u: L64) -> Self {
        u64::from_le(u.0) as usize
    }
}
impl L64 {
    pub fn as_u64(&self) -> u64 {
        u64::from_le(self.0)
    }
    pub fn as_usize(&self) -> usize {
        u64::from_le(self.0) as usize
    }
}
impl std::fmt::Display for L64 {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        self.0.fmt(fmt)
    }
}
impl Ord for L64 {
    fn cmp(&self, x: &Self) -> std::cmp::Ordering {
        u64::from_le(self.0).cmp(&u64::from_le(x.0))
    }
}
impl PartialOrd for L64 {
    fn partial_cmp(&self, x: &Self) -> Option<std::cmp::Ordering> {
        Some(u64::from_le(self.0).cmp(&u64::from_le(x.0)))
    }
}

Deletion in libpijul/src/pristine/mod.rs at line 26 [28.586748]

B:BD[54.99751] → [54.99751:100342]

B:BD[54.100342] → [63.14267:14362]

∅:D[63.14362] → [54.100457:100688]

B:BD[54.100457] → [54.100457:100688]

impl std::ops::Add<L64> for L64 {
    type Output = Self;
    fn add(self, x: L64) -> L64 {
        L64((u64::from_le(self.0) + u64::from_le(x.0)).to_le())
    }
}
impl std::ops::Add<usize> for L64 {
    type Output = Self;
    fn add(self, x: usize) -> L64 {
        L64((u64::from_le(self.0) + x as u64).to_le())
    }
}
impl std::ops::SubAssign<usize> for L64 {
    fn sub_assign(&mut self, x: usize) {
        self.0 = ((u64::from_le(self.0)) - x as u64).to_le()
    }
}
impl L64 {
    pub fn from_slice_le(s: &[u8]) -> Self {
        let mut u = 0u64;
        assert!(s.len() >= 8);
        unsafe { std::ptr::copy_nonoverlapping(s.as_ptr(), &mut u as *mut u64 as *mut u8, 8) }
        L64(u)
    }
    pub fn to_slice_le(&self, s: &mut [u8]) {
        assert!(s.len() >= 8);
        unsafe {
            std::ptr::copy_nonoverlapping(&self.0 as *const u64 as *const u8, s.as_mut_ptr(), 8)
        }
    }
}

Replacement in libpijul/src/pristine/edge.rs at line 166 [28.648958]
B:BD[54.119378] → [54.119378:119421]
```
        let pos = u64::from_le((pos.0).0);
```
[54.119378]
[63.17262]
```
        let pos = pos.0.as_u64();
```

Replacement in libpijul/src/output/archive.rs at line 267 [28.690044]

B:BD[83.1275] → [84.5649:5681]

B:BD[84.5681] → [43.5221:5325]

                    let mut l =
                        crate::alive::retrieve(&*txn_, txn_.graph(&channel_), output_item.pos, false)?;

[83.1275]

[85.0]

                    let mut l = crate::alive::retrieve(
                        &*txn_,
                        txn_.graph(&channel_),
                        output_item.pos,
                        false,
                    )?;

Replacement in libpijul/src/diff/replace.rs at line 307 [28.779907]
B:BD[9.100] → [9.100:130]
```
                        break
```
[9.100]
[28.790553]
```
                        break;
```

Replacement in libpijul/src/change.rs at line 304 [28.831311]

B:BD[20.239] → [20.239:290]

        return Err(MakeChangeError::InvalidChange)

[20.239]

[20.290]

        return Err(MakeChangeError::InvalidChange);

Replacement in libpijul/src/change.rs at line 343 [28.831311]

B:BD[20.428] → [20.428:479]

        return Err(MakeChangeError::InvalidChange)

[20.428]

[20.479]

        return Err(MakeChangeError::InvalidChange);

Replacement in libpijul/src/change.rs at line 1449 [28.831311]

B:BD[54.140483] → [86.0:83]

    info!("compressing with ZStd {}", zstd_seekable::version().to_str().unwrap());

[54.140483]

[18.25]

    info!(
        "compressing with ZStd {}",
        zstd_seekable::version().to_str().unwrap()
    );

Replacement in libpijul/src/change/text_changes.rs at line 29 [87.37976]
B:BD[20.1212] → [20.1212:1255]
```
    MakeChange(#[from]MakeChangeError<T>),
```
[20.1212]
[87.38343]
```
    MakeChange(#[from] MakeChangeError<T>),
```
Replacement in libpijul/src/change/text_changes.rs at line 202 [87.37976]
∅:D[88.10351] → [70.122912:122944]
∅:D[89.59097] → [70.122912:122944]
B:BD[87.43188] → [70.122912:122944]
B:BD[70.122944] → [20.1301:1380]
```
        let (mut deps, extra) =
            dependencies(txn, &channel.read(), change.hashed.changes.iter())?;
```
[89.59097]
[87.43278]
```
        let (mut deps, extra) = dependencies(txn, &channel.read(), change.hashed.changes.iter())?;
```

Replacement in libpijul/src/change/text_changes.rs at line 333 [87.37976]

B:BD[88.13315] → [88.13315:13395]

            start: new_vertex.start.0 .0,
            end: new_vertex.end.0 .0,

[88.13315]

[88.13395]

            start: new_vertex.start.0.as_u64(),
            end: new_vertex.end.0.as_u64(),

Replacement in libpijul/src/change/text_changes.rs at line 350 [87.37976]

B:BD[88.14013] → [88.14013:14056]

                    to_end: c.to.end.0 .0,

[88.14013]

[88.14056]

                    to_end: c.to.end.0.as_u64(),

Replacement in libpijul/src/change/text_changes.rs at line 374 [87.37976]

B:BD[88.14841] → [88.14841:14896]

                end: ChangePosition(L64(edge.to_end)),

[88.14841]

[88.14896]

                end: ChangePosition(L64(edge.to_end.to_le())),

Replacement in libpijul/src/change/text_changes.rs at line 500 [87.37976]

B:BD[88.17922] → [88.17922:18008]

                        start: n.start.0 .0,
                        end: n.end.0 .0,

[88.17922]

[88.18008]

                        start: n.start.0.as_u64(),
                        end: n.end.0.as_u64(),

Replacement in libpijul/src/change/text_changes.rs at line 598 [87.37976]

B:BD[56.1936] → [56.1936:1981]

                        start: n.start.0 .0,

[56.1936]

[56.1981]

                        start: n.start.0.as_u64(),

Replacement in libpijul/src/change/text_changes.rs at line 1184 [87.37976]
B:BD[87.88087] → [88.36064:36103]
```
    PrintablePos(change, pos.pos.0 .0)
```
[87.88087]
[87.88142]
```
    PrintablePos(change, pos.pos.0.as_u64())
```

Replacement in libpijul/src/change/parse.rs at line 396 [88.64713]

B:BD[23.11153] → [23.11153:11262]

    parse(i)
        .map_err(|_| nom::Err::Error(nom::error::Error::new(i, nom::error::ErrorKind::Verify)))

[23.11153]

[56.7469]

    parse(i).map_err(|_| nom::Err::Error(nom::error::Error::new(i, nom::error::ErrorKind::Verify)))

Replacement in libpijul/src/change/parse.rs at line 408 [88.64713]

B:BD[23.11519] → [23.11519:11628]

    parse(i)
        .map_err(|_| nom::Err::Error(nom::error::Error::new(i, nom::error::ErrorKind::Verify)))

[23.11519]

[56.7827]

    parse(i).map_err(|_| nom::Err::Error(nom::error::Error::new(i, nom::error::ErrorKind::Verify)))

Replacement in libpijul/src/apply.rs at line 583 [28.944089]
B:BD[25.319] → [25.319:345]
```
        is_on_path: false
```
[25.319]
[25.345]
```
        is_on_path: false,
```
Deletion in libpijul/src/apply.rs at line 589 [28.944089]
∅:D[25.394] → [90.2083:2084]
B:BD[90.2083] → [90.2083:2084]
Replacement in libpijul/src/apply.rs at line 591 [28.944089]
B:BD[25.512] → [25.512:533]
```
            continue
```
[25.512]
[25.533]
```
            continue;
```

Replacement in libpijul/src/apply.rs at line 595 [28.944089]

B:BD[25.581] → [25.581:640]

        stack.push(StackElt { is_on_path: true, .. elt });

[25.581]

[25.640]

        stack.push(StackElt {
            is_on_path: true,
            ..elt
        });

Replacement in libpijul/src/apply.rs at line 607 [28.944089]

B:BD[90.2385] → [25.747:849]

            for e in iter_adjacent(txn, channel, elt.vertex, EdgeFlags::empty(), EdgeFlags::all())? {

[90.2385]

[90.2484]

            for e in iter_adjacent(
                txn,
                channel,
                elt.vertex,
                EdgeFlags::empty(),
                EdgeFlags::all(),
            )? {

Replacement in libpijul/src/apply.rs at line 625 [28.944089]

B:BD[26.185] → [26.185:219]

                    return Ok(())

[26.185]

[90.2817]

                    return Ok(());

Replacement in libpijul/src/apply.rs at line 633 [28.944089]

B:BD[25.1049] → [25.1049:1091]

                        is_on_path: false

[25.1049]

[25.1091]

                        is_on_path: false,

Deletion in libpijul/src/apply.rs at line 640 [28.944089]
B:BD[25.1167] → [25.1167:1168]

Replacement in libpijul/src/apply.rs at line 651 [28.944089]

B:BD[25.1615] → [25.1615:1718]


            if let Some(last_on_path) = (&stack[..len - 1]).iter().rev().position(|x| x.is_on_path) {

[25.1615]

[90.3174]

            if let Some(last_on_path) = (&stack[..len - 1]).iter().rev().position(|x| x.is_on_path)
            {

Replacement in libpijul/src/apply.rs at line 934 [28.944089]

B:BD[90.8133] → [90.8133:8310]

∅:D[90.8310] → [91.1327:1384]

B:BD[91.1327] → [91.1327:1384]

                if has_missing_context_nondeleted(
                    txn,
                    channel,
                    change_id,
                    e,
                )
                .map_err(LocalApplyError::from_missing)?

[90.8133]

[90.8311]

                if has_missing_context_nondeleted(txn, channel, change_id, e)
                    .map_err(LocalApplyError::from_missing)?

Insertion in libpijul/src/apply.rs at line 1163 [28.944089]

[92.685]

[93.1660]

        debug!(
            "change position {:?} {:?}",
            ChangePosition(1u64.into()),
            ChangePosition(1u64.into()).0.as_u64()
        );

Replacement in libpijul/src/apply/vertex.rs at line 117 [59.90459]

B:BD[94.378] → [94.378:434]

                return Err(LocalApplyError::Corruption)

[94.378]

[94.434]

                return Err(LocalApplyError::Corruption);

Replacement in libpijul/src/apply/vertex.rs at line 165 [59.90459]

B:BD[94.685] → [94.685:745]

                    return Err(LocalApplyError::Corruption)

[94.685]

[94.745]

                    return Err(LocalApplyError::Corruption);

Replacement in libpijul/src/alive/retrieve.rs at line 50 [28.984582]
B:BD[43.7881] → [43.7881:7906]
```
                continue
```
[43.7881]
[43.7906]
```
                continue;
```

Replacement in libpijul/Cargo.toml at line 99 [28.1020742]

B:BD[28.1022980] → [15.0:82]

sanakirja = { version = "1.3", default-features = false, features = [ "crc32" ] }

[28.1022980]

[95.451]

sanakirja = { version = "1.4.0", default-features = false, features = [ "crc32" ] }

Deletion in Cargo.toml at line 3 [28.1030188]
∅:D[96.280] → [97.315972:315973]
B:BD[97.315972] → [97.315972:315973]
Replacement in Cargo.lock at line 2671 [98.35]
B:BD[98.56744] → [15.83:101]
```
version = "1.3.3"
```
[98.56744]
[98.56763]
```
version = "1.4.0"
```

Replacement in Cargo.lock at line 2673 [98.35]

B:BD[98.56828] → [15.102:180]

checksum = "766699f1bb95f2e358c1ec0945da82b40097ec29a3a61636833f5ff27071c392"

[98.56828]

[98.56906]

checksum = "2b783ffdf047e99d9a2fd1d50724d72e9acdd74f157168d74fd70862f8e35236"

Insertion in Cargo.lock at line 2682 [98.35]
[98.57021]
[98.57021]
```
 "serde",
```
Replacement in Cargo.lock at line 2688 [98.35]
B:BD[98.57074] → [15.181:199]
```
version = "1.3.3"
```
[98.57074]
[98.57093]
```
version = "1.4.0"
```

Replacement in Cargo.lock at line 2690 [98.35]

B:BD[98.57158] → [15.200:278]

checksum = "4b18ebf28e53f067c2867f2cbae572f5e5320c1074ad2f9e6ed309df22277de6"

[98.57158]

[98.57236]

checksum = "e8278ad92194c3131827375ad63c7b59f167c0bbe83de1e63813929dd531e2c6"

Formatting + big-endian Sanakirja

Dependencies

In channels

Change contents

Replacement in pijul/src/remote/mod.rs at line 789 [28.52474]

Replacement in pijul/src/remote/mod.rs at line 1286 [28.52474]

Replacement in pijul/src/remote/mod.rs at line 1382 [28.52474]

Replacement in pijul/src/remote/http.rs at line 41 [33.10]

Replacement in pijul/src/remote/http.rs at line 167 [33.10]

Replacement in pijul/src/remote/http.rs at line 173 [33.10]

Replacement in pijul/src/remote/http.rs at line 541 [33.10]

Replacement in pijul/src/identity/mod.rs at line 133 [37.15627]

Replacement in pijul/src/identity/mod.rs at line 149 [37.15627]

Replacement in pijul/src/identity/mod.rs at line 272 [37.15627]

Insertion in pijul/src/identity/create.rs at line 8 [37.28175]

Deletion in pijul/src/identity/create.rs at line 12 [37.28175]

Replacement in pijul/src/identity/create.rs at line 14 [37.28175]

Replacement in pijul/src/commands/tag.rs at line 290 [39.74]

Replacement in pijul/src/commands/protocol.rs at line 413 [28.123281]

Replacement in pijul/src/commands/identity.rs at line 443 [37.40825]

Deletion in pijul/src/commands/dependents.rs at line 1 [42.243]

Insertion in pijul/src/commands/dependents.rs at line 3 [42.243]

Replacement in pijul/src/commands/dependents.rs at line 37 [42.243]

Replacement in pijul/src/commands/dependents.rs at line 65 [42.243]

Replacement in pijul/src/commands/debug.rs at line 55 [28.177758]

Replacement in pijul/src/commands/debug.rs at line 84 [28.177758]

Insertion in pijul/src/commands/client.rs at line 3 [32.4568]

Deletion in pijul/src/commands/client.rs at line 8 [32.4568]

Replacement in pijul/src/commands/client.rs at line 9 [32.4568]

Deletion in pijul/src/commands/client.rs at line 20 [32.4568]

Replacement in pijul/src/commands/client.rs at line 29 [32.4568]

Deletion in pijul/src/commands/client.rs at line 36 [32.4568]

Replacement in pijul/src/commands/client.rs at line 65 [32.4568]

Replacement in pijul/src/commands/client.rs at line 80 [32.4568]

Replacement in pijul/src/commands/client.rs at line 85 [32.4568]

Replacement in pijul/src/commands/client.rs at line 111 [32.4568]

Replacement in pijul/src/commands/apply.rs at line 139 [28.194289]

Replacement in pijul/Cargo.toml at line 82 [28.196374]

Replacement in libpijul/src/vertex_buffer.rs at line 165 [28.217202]

Replacement in libpijul/src/vertex_buffer.rs at line 184 [28.217202]

Replacement in libpijul/src/vertex_buffer.rs at line 204 [28.217202]

Replacement in libpijul/src/vertex_buffer.rs at line 229 [28.217202]

Deletion in libpijul/src/unrecord/mod.rs at line 589 [28.231493]

Replacement in libpijul/src/unrecord/mod.rs at line 611 [28.231493]

Replacement in libpijul/src/unrecord/mod.rs at line 629 [28.231493]

Deletion in libpijul/src/unrecord/mod.rs at line 659 [28.231493]

Deletion in libpijul/src/unrecord/mod.rs at line 674 [28.231493]

Replacement in libpijul/src/unrecord/mod.rs at line 680 [28.231493]

Deletion in libpijul/src/unrecord/mod.rs at line 695 [28.231493]

Solving an order conflict in libpijul/src/unrecord/mod.rs at line 695 [28.231493]