Debugging, tests, etc.

Dependencies

• [2] R5AJGJPT Minor performance improvement
• [3] FMN7X4J2 Micro-improvements, now noticeably faster than std::collections::BTreeMap
• [4] EHJFNMB2 Debugging
• [5] OP6SVMOD Resetting history

Change contents

• edit in sanakirja-core/src/lib.rs at line 22
  [5.764]

  [5.764]
  + #[macro_export]
• replacement in sanakirja-core/src/lib.rs at line 50
  [5.1496]→[5.1496:1615](∅→∅)
  − unsafe fn read<T, K: Representable<T>, V: Representable<T>>(p: *mut u8) -> (*mut K, *mut V) {

  − let k = p as *mut K;
  [5.1496]

  [5.1615]
  + unsafe fn read<T, K: Representable<T>, V: Representable<T>>(p: *const u8) -> (*const K, *const V) {

  + let k = p as *const K;
• replacement in sanakirja-core/src/lib.rs at line 56
  [5.1725]→[5.1725:1746](∅→∅)
  − (k, v as *mut V)
  [5.1725]

  [5.1746]
  + (k, v as *const V)
• replacement in sanakirja-core/src/lib.rs at line 65
  [5.1972]→[5.1972:2061](∅→∅)
  − unsafe fn entry_size<T, K: Representable<T>, V: Representable<T>>(k: *mut u8) -> usize {
  [5.1972]

  [5.2061]
  + unsafe fn entry_size<T, K: Representable<T>, V: Representable<T>>(k: *const u8) -> usize {
• replacement in sanakirja-core/src/lib.rs at line 78
  [5.2429]→[5.2429:2447](∅→∅)
  − pub struct Page {
  [5.2429]

  [5.2447]
  + pub struct CowPage {
• edit in sanakirja-core/src/lib.rs at line 83
  [5.2494]

  [5.2494]
  + const PAGE_SIZE: usize = 4096;

  +
• replacement in sanakirja-core/src/lib.rs at line 86
  [5.2524]→[5.2524:2554](∅→∅)
  − pub struct MutPage(pub Page);
  [5.2524]

  [5.2554]
  + pub struct Page<'a> {

  + pub data: &'a [u8; PAGE_SIZE],

  + pub offset: u64,

  + }

  +

  + impl CowPage {

  + pub fn as_page(&self) -> Page {

  + unsafe { core::mem::transmute(*self) }

  + }

  + }
• edit in sanakirja-core/src/lib.rs at line 97
  [5.2555]

  [5.2555]
  + #[derive(Debug)]

  + pub struct MutPage(pub CowPage);

  +
• replacement in sanakirja-core/src/lib.rs at line 114
  [5.2897]→[5.2897:2961](∅→∅)
  − fn load_page(&self, off: u64) -> Result<Page, Self::Error>;
  [5.2897]

  [5.2961]
  + fn load_page(&self, off: u64) -> Result<CowPage, Self::Error>;
• edit in sanakirja-core/src/btree/put.rs at line 13
  [5.3963]

  [5.3975]
  + use log::*;
• edit in sanakirja-core/src/btree/put.rs at line 27
  [5.4449]

  [5.4449]
  + debug!("{:?}", cursor.pointer);

  +
• edit in sanakirja-core/src/btree/put.rs at line 59
  [5.5216]

  [3.0]
  + debug!("pointer: {:?}", cursor.pointer);
• edit in sanakirja-core/src/btree/put.rs at line 72
  [3.118]

  [3.118]
  + debug!("splitting {:?}", cur.page);
• replacement in sanakirja-core/src/btree/put.rs at line 85
  [5.5684]→[5.5684:5763](∅→∅)
  − let p = txn.alloc_page()?;

  − P::init(p);
  [5.5684]

  [5.5763]
  + debug!("splitting the root");

  + let mut p = txn.alloc_page()?;

  + P::init(&mut p);
• replacement in sanakirja-core/src/btree/put.rs at line 92
  [5.5879]→[5.5879:5927](∅→∅)
  − &P::first_cursor(&p.0),
  [5.5879]

  [5.5927]
  + &P::first_cursor(p.0.as_page()),
• edit in sanakirja-core/src/btree/put.rs at line 102
  [5.7298]

  [5.7298]
  + debug!("ok");
• replacement in sanakirja-core/src/btree/put.rs at line 146
  [5.8159]→[5.8159:8256](∅→∅)
  − let mut c = P::first_cursor(&cur.page);

  − let left = P::left_child(&cur.page, &c);
  [5.8159]

  [5.8256]
  + let mut c = P::first_cursor(cur.page.as_page());

  + let left = P::left_child(cur.page.as_page(), &c);
• replacement in sanakirja-core/src/btree/put.rs at line 151
  [5.8332]→[5.8332:8397](∅→∅)
  − while let Some((k, v, r)) = P::next(&cur.page, &mut c) {
  [5.8332]

  [5.8397]
  + while let Some((k, v, r)) = P::next(cur.page.as_page(), &mut c) {
• edit in sanakirja-core/src/btree/page.rs at line 18
  [5.8867]

  [5.8867]
  + #[derive(Debug)]
• replacement in sanakirja-core/src/btree/page.rs at line 29
  [5.8997]→[5.8997:9031](∅→∅)
  − self.n = 1; // dirty page
  [5.8997]

  [5.9031]
  + self.n = (1u16).to_le(); // dirty page
• replacement in sanakirja-core/src/btree/page.rs at line 66
  [5.9834]→[5.9834:9926](∅→∅)
  − fn init(page: MutPage) {

  − unsafe { (&mut *(page.0.data as *mut Header)).init() }
  [5.9834]

  [5.9926]
  + fn init(page: &mut MutPage) {

  + debug!("init {:?}", page);

  + let h = header_mut(page);

  + h.init();

  + debug!("init: {:?}", h);
• replacement in sanakirja-core/src/btree/page.rs at line 73
  [5.9933]→[5.9933:10094](∅→∅)
  − fn clean(page: MutPage) {

  − unsafe {

  − let hdr = &mut *header_mut(page);

  − hdr.n = (u16::from_le(hdr.n) & 0xfff).to_le()

  − }
  [5.9933]

  [5.10094]
  + fn clean(page: &mut MutPage) {

  + let hdr = header_mut(page);

  + hdr.n = (u16::from_le(hdr.n) & 0xfff).to_le()
• replacement in sanakirja-core/src/btree/page.rs at line 79
  [5.10157]→[5.10157:10234](∅→∅)
  − let mut occupied = unsafe {

  − let hdr = &*header(&m.page);
  [5.10157]

  [5.10234]
  + let mut occupied = {

  + let hdr = header(m.page.as_page());
• replacement in sanakirja-core/src/btree/page.rs at line 89
  [5.10508]→[5.10508:10573](∅→∅)
  − occupied -= Self::current_size(&m.page, &m.c1) as usize;
  [5.10508]

  [5.10573]
  + if m.skip_first {

  + occupied -= Self::current_size(m.page.as_page(), &m.c1) as usize;

  + }
• replacement in sanakirja-core/src/btree/page.rs at line 93
  [5.10614]→[5.10614:10687](∅→∅)
  − occupied += unsafe { crate::alloc_size(&*k, &*v) as usize };
  [5.10614]

  [5.10687]
  + occupied += crate::alloc_size(k, v) as usize;
• replacement in sanakirja-core/src/btree/page.rs at line 107
  [5.10960]→[5.10960:10987](∅→∅)
  − page: crate::Page,
  [5.10960]

  [5.10987]
  + page: CowPage,
• replacement in sanakirja-core/src/btree/page.rs at line 115
  [5.11143]→[5.11143:11184](∅→∅),[5.11220]→[5.11220:11319](∅→∅),[5.11359]→[5.11359:11455](∅→∅)
  − unsafe {

  − if r == 0 {

  − put::<_, _, _, Leaf>(txn, page, mutable, c.cur, k0, v0, 0, 0)

  − } else {

  − put::<_, _, _, Internal>(txn, page, mutable, c.cur, k0, v0, l, r)

  − }
  [5.11143]

  [5.11455]
  + if r == 0 {

  + put::<_, _, _, Leaf>(txn, page, mutable, c.cur, k0, v0, 0, 0)

  + } else {

  + put::<_, _, _, Internal>(txn, page, mutable, c.cur, k0, v0, l, r)
• replacement in sanakirja-core/src/btree/page.rs at line 124
  [5.11519]→[5.11519:11546](∅→∅)
  − page: crate::Page,
  [5.11519]

  [5.11546]
  + page: CowPage,
• replacement in sanakirja-core/src/btree/page.rs at line 131
  [5.11691]→[5.11691:11747](∅→∅)
  − let page = if mutable && Self::is_dirty(page) {
  [5.11691]

  [5.11747]
  + debug!("update_left_child: {:?} {:?} {:?}", page, mutable, header(page.as_page()));

  + let page = if mutable && Self::is_dirty(page.as_page()) {
• replacement in sanakirja-core/src/btree/page.rs at line 134
  [5.11770]→[5.11770:11796](∅→∅)
  − MutPage(page)
  [5.11770]

  [5.11796]
  + unsafe { core::mem::transmute(page) }
• replacement in sanakirja-core/src/btree/page.rs at line 136
  [5.11813]→[5.11813:12302](∅→∅)
  − unsafe {

  − let new = txn.alloc_page()?;

  − <Page<K, V> as BTreeMutPage<T, K, V>>::init(new);

  − let s = Internal::offset_slice::<T, K, V>(page);

  − let hdr = &mut *header_mut(new);

  − let mut n = 0;

  − clone::<T, K, V, Internal>(hdr, page, new, s, &mut n);

  − let b = if Self::is_dirty(page) { 1 } else { 0 };

  − freed = page.offset | b;

  − new

  − }
  [5.11813]

  [5.12302]
  + let mut new = txn.alloc_page()?;

  + <Page<K, V> as BTreeMutPage<T, K, V>>::init(&mut new);

  + let s = Internal::offset_slice::<T, K, V>(page.as_page());

  + let mut n = 0;

  + clone::<T, K, V, Internal>(page.as_page(), &mut new, s, &mut n);

  + let b = if Self::is_dirty(page.as_page()) { 1 } else { 0 };

  + freed = page.offset | b;

  + new
• replacement in sanakirja-core/src/btree/page.rs at line 153
  [5.12564]→[5.12564:12658](∅→∅)
  − fn del(txn: &mut T, page: crate::Page, c: &Cursor, l: u64) -> Result<MutPage, T::Error> {
  [5.12564]

  [5.12658]
  + fn del(txn: &mut T, page: crate::CowPage, c: &Cursor, l: u64) -> Result<MutPage, T::Error> {
• replacement in sanakirja-core/src/btree/page.rs at line 155
  [5.12692]→[5.12692:14388](∅→∅)
  − if Self::is_dirty(page) {

  − let page = MutPage(page);

  − unsafe {

  − let hdr = header_mut(page);

  − if c.is_leaf {

  − let n = (&*hdr).n() as usize;

  − if let Some(f) = fixed_size::<T, K, V>() {

  − let al = K::ALIGN.max(V::ALIGN);

  − let hdr_size = (HDR + al - 1) & !(al - 1);

  − let off = c.cur * f;

  − let kv_ptr = page.0.data.add(hdr_size + off);

  − core::ptr::copy(kv_ptr.add(f), kv_ptr, f * (n - c.cur - 1));

  − (&mut *hdr).decr(f);

  − } else {

  − let ptr = page.0.data.add(HDR + c.cur * 2) as *mut u16;

  − let kv_ptr = page.0.data.add((*ptr) as usize);

  − let size = entry_size::<T, K, V>(kv_ptr);

  − core::ptr::copy(ptr.offset(1), ptr, n - c.cur);

  − (&mut *hdr).decr(size);

  − }

  − } else {

  − let ptr = page.0.data.add(HDR + c.cur * 8) as *mut u64;

  − let off = (u64::from_le(*ptr) & 0xfff) as usize;

  − let kv_ptr = page.0.data.add(off);

  − let size = entry_size::<T, K, V>(kv_ptr);

  − core::ptr::copy(ptr.offset(1), ptr, (&*hdr).n() as usize - c.cur);

  − (&mut *hdr).decr(size);

  − };

  − if l > 0 {

  − assert!(!c.is_leaf);

  − // Updating the left page if necessary.

  − let off = (page.0.data.add(HDR) as *mut u64).offset(c.cur as isize - 1);
  [5.12692]

  [5.14388]
  + if Self::is_dirty(page.as_page()) {

  + let p = page.data;

  + let mut page: MutPage = unsafe { core::mem::transmute(page) };

  + let hdr = header_mut(&mut page);

  + unsafe { if c.is_leaf {

  + let n = hdr.n() as usize;

  + if let Some(f) = fixed_size::<T, K, V>() {

  + let al = K::ALIGN.max(V::ALIGN);

  + let hdr_size = (HDR + al - 1) & !(al - 1);

  + let off = c.cur * f;

  + let kv_ptr = p.add(hdr_size + off);

  + core::ptr::copy(kv_ptr.add(f), kv_ptr, f * (n - c.cur - 1));

  + hdr.decr(f);

  + } else {

  + let ptr = p.add(HDR + c.cur * 2) as *mut u16;

  + let kv_ptr = p.add((*ptr) as usize);

  + let size = entry_size::<T, K, V>(kv_ptr);

  + core::ptr::copy(ptr.offset(1), ptr, n - c.cur);

  + hdr.decr(size);

  + }

  + } else {

  + let ptr = p.add(HDR + c.cur * 8) as *mut u64;

  + let off = (u64::from_le(*ptr) & 0xfff) as usize;

  + let kv_ptr = p.add(off);

  + let size = entry_size::<T, K, V>(kv_ptr);

  + core::ptr::copy(ptr.offset(1), ptr, (&*hdr).n() as usize - c.cur);

  + (&mut *hdr).decr(size);

  + }};

  + if l > 0 {

  + assert!(!c.is_leaf);

  + // Updating the left page if necessary.

  + unsafe {

  + let off = (p as *mut u64).offset(c.cur as isize - 1);
• edit in sanakirja-core/src/btree/page.rs at line 190
  [5.14477]→[5.14477:14566](∅→∅)
  − (&mut *hdr).set_n(u16::from_le((&*hdr).n) - 1);

  − Ok(page)
• edit in sanakirja-core/src/btree/page.rs at line 191
  [5.14580]

  [5.14580]
  + hdr.set_n(u16::from_le((&*hdr).n) - 1);

  + Ok(page)
• replacement in sanakirja-core/src/btree/page.rs at line 195
  [5.14618]→[5.14618:14729](∅→∅)
  − let new = txn.alloc_page()?;

  − <Page<K, V> as BTreeMutPage<T, K, V>>::init(new);
  [5.14618]

  [5.14729]
  + let mut new = txn.alloc_page()?;

  + <Page<K, V> as BTreeMutPage<T, K, V>>::init(&mut new);
• replacement in sanakirja-core/src/btree/page.rs at line 198
  [5.14760]→[5.14760:14825](∅→∅)
  − let s = Leaf::offset_slice::<T, K, V>(page);
  [5.14760]

  [5.14825]
  + let s = Leaf::offset_slice::<T, K, V>(page.as_page());
• edit in sanakirja-core/src/btree/page.rs at line 200
  [5.14879]→[5.14879:14932](∅→∅)
  − let hdr = &mut *header_mut(new);
• replacement in sanakirja-core/src/btree/page.rs at line 201
  [5.14967]→[5.14967:15111](∅→∅)
  − clone::<T, K, V, Leaf>(hdr, page, new, s0, &mut n);

  − clone::<T, K, V, Leaf>(hdr, page, new, s1, &mut n);
  [5.14967]

  [5.15111]
  + clone::<T, K, V, Leaf>(page.as_page(), &mut new, s0, &mut n);

  + clone::<T, K, V, Leaf>(page.as_page(), &mut new, s1, &mut n);
• replacement in sanakirja-core/src/btree/page.rs at line 204
  [5.15136]→[5.15136:15205](∅→∅)
  − let s = Internal::offset_slice::<T, K, V>(page);
  [5.15136]

  [5.15205]
  + let s = Internal::offset_slice::<T, K, V>(page.as_page());
• edit in sanakirja-core/src/btree/page.rs at line 206
  [5.15259]→[5.15259:15312](∅→∅)
  − let hdr = &mut *header_mut(new);
• replacement in sanakirja-core/src/btree/page.rs at line 207
  [5.15347]→[5.15347:15423](∅→∅)
  − clone::<T, K, V, Internal>(hdr, page, new, s0, &mut n);
  [5.15347]

  [5.15423]
  + clone::<T, K, V, Internal>(page.as_page(), &mut new, s0, &mut n);
• replacement in sanakirja-core/src/btree/page.rs at line 210
  [5.15539]→[5.15539:15615](∅→∅)
  − clone::<T, K, V, Internal>(hdr, page, new, s1, &mut n);
  [5.15539]

  [5.15615]
  + clone::<T, K, V, Internal>(page.as_page(), &mut new, s1, &mut n);
• replacement in sanakirja-core/src/btree/page.rs at line 219
  [5.15740]→[5.15740:15779](∅→∅)
  − m: &mut Concat<T, K, V, Self>,
  [5.15740]

  [5.15779]
  + m: &mut Concat<'a, T, K, V, Self>,
• replacement in sanakirja-core/src/btree/page.rs at line 228
  [5.16104]→[5.16104:16179](∅→∅)
  − 2 + unsafe { alloc_size::<T, K, V>(&*m.mid.0, &*m.mid.1) }
  [5.16104]

  [5.16179]
  + 2 + alloc_size::<T, K, V>(m.mid.0, m.mid.1)
• replacement in sanakirja-core/src/btree/page.rs at line 231
  [5.16210]→[5.16210:16281](∅→∅)
  − 8 + unsafe { alloc_size::<T, K, V>(&*m.mid.0, &*m.mid.1) }
  [5.16210]

  [5.16281]
  + 8 + alloc_size::<T, K, V>(m.mid.0, m.mid.1)
• replacement in sanakirja-core/src/btree/page.rs at line 234
  [5.16341]→[5.16341:16415](∅→∅)
  − let occupied = unsafe {

  − let hdr = &*header(&m.other);
  [5.16341]

  [5.16415]
  + let occupied = {

  + let hdr = header(m.other.as_page());
• edit in sanakirja-core/src/btree/page.rs at line 239
  [5.16536]

  [5.16536]
  + debug!("size = {:?} {:?} {:?} {:?} {:?}", left_size, mid_size, occupied, hdr_size, size);
• replacement in sanakirja-core/src/btree/page.rs at line 242
  [5.16588]→[5.16588:16691](∅→∅)
  − let new = txn.alloc_page()?;

  − <Page<K, V> as BTreeMutPage<T, K, V>>::init(new);
  [5.16588]

  [5.16691]
  + let mut new = txn.alloc_page()?;

  + <Page<K, V> as BTreeMutPage<T, K, V>>::init(&mut new);
• replacement in sanakirja-core/src/btree/page.rs at line 246
  [5.16755]→[5.16755:16806](∅→∅)
  − merge::<_, _, _, Leaf>(new, m)
  [5.16755]

  [5.16806]
  + merge::<_, _, _, Leaf>(&mut new, m)
• replacement in sanakirja-core/src/btree/page.rs at line 248
  [5.16831]→[5.16831:16886](∅→∅)
  − merge::<_, _, _, Internal>(new, m)
  [5.16831]

  [5.16886]
  + merge::<_, _, _, Internal>(&mut new, m)
• replacement in sanakirja-core/src/btree/page.rs at line 251
  [5.16918]→[5.16918:16976](∅→∅)
  − let b0 = if Self::is_dirty(m.modified.page) {
  [5.16918]

  [5.16976]
  + let b0 = if Self::is_dirty(m.modified.page.as_page()) {
• replacement in sanakirja-core/src/btree/page.rs at line 256
  [5.17048]→[5.17048:17114](∅→∅)
  − let b1 = if Self::is_dirty(m.other) { 1 } else { 0 };
  [5.17048]

  [5.17114]
  + let b1 = if Self::is_dirty(m.other.as_page()) { 1 } else { 0 };
• replacement in sanakirja-core/src/btree/page.rs at line 263
  [5.17328]→[5.17328:17451](∅→∅)
  − let rc = <Page<K, V>>::first_cursor(&m.other);

  − let first_size = <Page<K, V>>::current_size(&m.other, &rc);
  [5.17328]

  [5.17451]
  + let rc = <Page<K, V>>::first_cursor(m.other.as_page());

  + let first_size = <Page<K, V>>::current_size(m.other.as_page(), &rc);
• replacement in sanakirja-core/src/btree/page.rs at line 267
  [5.17574]→[5.17574:18250](∅→∅)
  − unsafe {

  − return Ok(Op::Put(if let Some((k, v, r)) = m.modified.ins {

  − Self::replace(

  − txn,

  − m.modified.page,

  − m.modified.mutable,

  − &m.modified.c1,

  − &*k,

  − &*v,

  − m.modified.l,

  − r,

  − )?

  − } else {

  − Put::Ok(Ok {

  − page: Self::del(txn, m.modified.page, &m.modified.c1, m.modified.l)?,

  − freed: 0,

  − })

  − }));

  − }
  [5.17574]

  [5.18250]
  + return Ok(Op::Put(if let Some((k, v, r)) = m.modified.ins {

  + Self::replace(

  + txn,

  + m.modified.page,

  + m.modified.mutable,

  + &m.modified.c1,

  + &*k,

  + &*v,

  + m.modified.l,

  + r,

  + )?

  + } else {

  + Put::Ok(Ok {

  + page: Self::del(txn, m.modified.page, &m.modified.c1, m.modified.l)?,

  + freed: 0,

  + })

  + }));
• replacement in sanakirja-core/src/btree/page.rs at line 285
  [5.18260]→[5.18260:18457](∅→∅)
  − unsafe {

  − if m.modified.c0.is_leaf {

  − rebalance::<_, _, _, Leaf>(txn, m)

  − } else {

  − rebalance::<_, _, _, Internal>(txn, m)

  − }
  [5.18260]

  [5.18457]
  + if m.modified.c0.is_leaf {

  + rebalance::<_, _, _, Leaf>(txn, m)

  + } else {

  + rebalance::<_, _, _, Internal>(txn, m)
• replacement in sanakirja-core/src/btree/page.rs at line 297
  [5.18628]→[5.18628:18726](∅→∅)
  − unsafe {

  − let hdr = &*header(&page);

  − hdr.n & 0x8000 != 0

  − }
  [5.18628]

  [5.18726]
  + header(page).is_dirty()
• replacement in sanakirja-core/src/btree/page.rs at line 300
  [5.18733]→[5.18733:18794](∅→∅)
  − fn is_empty(_: &crate::Page, c: &Self::Cursor) -> bool {
  [5.18733]

  [5.18794]
  + fn is_empty(_: crate::Page, c: &Self::Cursor) -> bool {
• replacement in sanakirja-core/src/btree/page.rs at line 304
  [5.18851]→[5.18851:19098](∅→∅)
  − fn first_cursor(p: &crate::Page) -> Self::Cursor {

  − unsafe {

  − let hdr = &*header(p);

  − Cursor {

  − cur: 0,

  − total: hdr.n() as usize,

  − is_leaf: hdr.is_leaf(),

  − }
  [5.18851]

  [5.19098]
  + fn first_cursor(p: crate::Page) -> Self::Cursor {

  + let hdr = header(p);

  + Cursor {

  + cur: 0,

  + total: hdr.n() as usize,

  + is_leaf: hdr.is_leaf(),
• replacement in sanakirja-core/src/btree/page.rs at line 312
  [5.19114]→[5.19114:19392](∅→∅)
  − fn last_cursor(p: &crate::Page) -> Self::Cursor {

  − unsafe {

  − let hdr = &*header(p);

  − let total = hdr.n() as usize;

  − Cursor {

  − cur: total - 1,

  − total,

  − is_leaf: hdr.is_leaf(),

  − }
  [5.19114]

  [5.19392]
  + fn last_cursor(p: crate::Page) -> Self::Cursor {

  + let hdr = header(p);

  + let total = hdr.n() as usize;

  + Cursor {

  + cur: total - 1,

  + total,

  + is_leaf: hdr.is_leaf(),
• replacement in sanakirja-core/src/btree/page.rs at line 321
  [5.19408]→[5.19408:19505](∅→∅)
  − unsafe fn unchecked_current(page: &crate::Page, c: &Self::Cursor) -> (*mut K, *mut V, u64) {
  [5.19408]

  [5.19505]
  + unsafe fn unchecked_current<'a>(page: crate::Page<'a>, c: &Self::Cursor) -> (&'a K, &'a V, u64) {
• replacement in sanakirja-core/src/btree/page.rs at line 328
  [5.19749]→[5.19749:19836](∅→∅)
  − u16::from_le(*(page.data.add(HDR + c.cur * 2) as *const u16)) as usize
  [5.19749]

  [5.19836]
  + u16::from_le(*(page.data.as_ptr().add(HDR + c.cur * 2) as *const u16)) as usize
• replacement in sanakirja-core/src/btree/page.rs at line 330
  [5.19851]→[5.19851:19944](∅→∅)
  − let (k, v) = read::<T, K, V>(page.data.add(off as usize));

  − (k, v, 0)
  [5.19851]

  [5.19944]
  + let (k, v) = read::<T, K, V>(page.data.as_ptr().add(off as usize));

  + (&*k, &*v, 0)
• replacement in sanakirja-core/src/btree/page.rs at line 333
  [5.19961]→[5.19961:20159](∅→∅)
  − let off = u64::from_le(*(page.data.add(HDR) as *const u64).add(c.cur));

  − let (k, v) = read::<T, K, V>(page.data.add((off & 0xfff) as usize));

  − (k, v, off & !0xfff)
  [5.19961]

  [5.20159]
  + let off = u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).add(c.cur));

  + let (k, v) = read::<T, K, V>(page.data.as_ptr().add((off & 0xfff) as usize));

  + (&*k, &*v, off & !0xfff)
• replacement in sanakirja-core/src/btree/page.rs at line 338
  [5.20175]→[5.20175:20299](∅→∅)
  − unsafe fn unchecked_current_ptr(page: &crate::Page, c: &Self::Cursor) -> *mut u8 {

  − page.data.add(if c.is_leaf {
  [5.20175]

  [5.20299]
  + unsafe fn unchecked_current_ptr(page: crate::Page, c: &Self::Cursor) -> *const u8 {

  + page.data.as_ptr().add(if c.is_leaf {
• replacement in sanakirja-core/src/btree/page.rs at line 345
  [5.20510]→[5.20510:20597](∅→∅)
  − u16::from_le(*(page.data.add(HDR + c.cur * 2) as *const u16)) as usize
  [5.20510]

  [5.20597]
  + u16::from_le(*(page.data.as_ptr().add(HDR + c.cur * 2) as *const u16)) as usize
• replacement in sanakirja-core/src/btree/page.rs at line 348
  [5.20628]→[5.20628:20721](∅→∅)
  − (u64::from_le(*(page.data.add(HDR + c.cur * 8) as *const u64)) & 0xfff) as usize
  [5.20628]

  [5.20721]
  + (u64::from_le(*(page.data.as_ptr().add(HDR + c.cur * 8) as *const u64)) & 0xfff) as usize
• replacement in sanakirja-core/src/btree/page.rs at line 351
  [5.20738]→[5.20738:20807](∅→∅)
  − fn current_size(page: &crate::Page, c: &Self::Cursor) -> usize {
  [5.20738]

  [5.20807]
  + fn current_size(page: crate::Page, c: &Self::Cursor) -> usize {
• replacement in sanakirja-core/src/btree/page.rs at line 359
  [5.21038]→[5.21038:21132](∅→∅)
  − .add(u16::from_le(*(page.data.add(HDR) as *const u16).add(c.cur))
  [5.21038]

  [5.21132]
  + .as_ptr()

  + .add(u16::from_le(*(page.data.as_ptr().add(HDR) as *const u16).add(c.cur))
• replacement in sanakirja-core/src/btree/page.rs at line 365
  [5.21236]→[5.21236:21394](∅→∅)
  − 8 + entry_size::<T, K, V>(page.data.add(

  − (u64::from_le(*(page.data.add(HDR) as *const u64).add(c.cur)) & 0xfff) as usize,
  [5.21236]

  [5.21394]
  + 8 + entry_size::<T, K, V>(page.data.as_ptr().add(

  + (u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).add(c.cur)) & 0xfff) as usize,
• replacement in sanakirja-core/src/btree/page.rs at line 371
  [5.21443]→[5.21443:21513](∅→∅)
  − fn move_next(_page: &crate::Page, c: &mut Self::Cursor) -> bool {
  [5.21443]

  [5.21513]
  + fn move_next(_page: crate::Page, c: &mut Self::Cursor) -> bool {
• replacement in sanakirja-core/src/btree/page.rs at line 379
  [5.21634]→[5.21634:21699](∅→∅)
  − fn left_child(page: &crate::Page, c: &Self::Cursor) -> u64 {
  [5.21634]

  [5.21699]
  + fn move_prev(_page: crate::Page, c: &mut Self::Cursor) -> bool {

  + if c.cur > 0 {

  + c.cur -= 1;

  + true

  + } else {

  + false

  + }

  + }

  + fn left_child(page: crate::Page, c: &Self::Cursor) -> u64 {
• replacement in sanakirja-core/src/btree/page.rs at line 391
  [5.21753]→[5.21753:21841](∅→∅)
  − let off = unsafe { *(page.data.add((HDR + c.cur * 8) - 8) as *const u64) };
  [5.21753]

  [5.21841]
  + let off = unsafe { *(page.data.as_ptr().add((HDR + c.cur * 8) - 8) as *const u64) };
• replacement in sanakirja-core/src/btree/page.rs at line 395
  [5.21896]→[5.21896:21962](∅→∅)
  − fn right_child(page: &crate::Page, c: &Self::Cursor) -> u64 {
  [5.21896]

  [5.21962]
  + fn right_child(page: crate::Page, c: &Self::Cursor) -> u64 {
• replacement in sanakirja-core/src/btree/page.rs at line 399
  [5.22016]→[5.22016:22098](∅→∅)
  − let off = unsafe { *(page.data.add(HDR + c.cur * 8) as *const u64) };
  [5.22016]

  [5.22098]
  + let off = unsafe { *(page.data.as_ptr().add(HDR + c.cur * 8) as *const u64) };
• replacement in sanakirja-core/src/btree/page.rs at line 405
  [5.22193]→[5.22193:22221](∅→∅)
  − page: &crate::Page,
  [5.22193]

  [5.22221]
  + page: crate::Page,
• replacement in sanakirja-core/src/btree/page.rs at line 409
  [5.22285]→[5.22285:22339](∅→∅)
  − ) -> Result<(&'a mut K, &'a mut V, u64), usize> {
  [5.22285]

  [5.22339]
  + ) -> Result<(&'a K, &'a V, u64), usize> {
• replacement in sanakirja-core/src/btree/page.rs at line 411
  [5.22356]→[5.22356:22435](∅→∅)
  − let hdr = &*header(&page);

  − c.total = hdr.n() as usize;
  [5.22356]

  [5.22435]
  + let lookup = lookup(txn, page, c, k0, v0);
• edit in sanakirja-core/src/btree/page.rs at line 413
  [5.22459]→[5.22459:22499](∅→∅),[5.22538]→[5.22538:22942](∅→∅),[5.22942]→[3.1108:1202](∅→∅),[3.1202]→[5.23036:23130](∅→∅),[5.23036]→[5.23036:23130](∅→∅),[5.23130]→[3.1203:1310](∅→∅),[3.1310]→[5.23163:23225](∅→∅),[5.23163]→[5.23163:23225](∅→∅),[5.23225]→[3.1311:1360](∅→∅),[3.1360]→[5.23274:23479](∅→∅),[5.23274]→[5.23274:23479](∅→∅),[5.23479]→[3.1361:1603](∅→∅),[3.1603]→[5.23713:23807](∅→∅),[5.23713]→[5.23713:23807](∅→∅),[5.23807]→[3.1604:1859](∅→∅),[3.1859]→[5.23840:23902](∅→∅),[5.23840]→[5.23840:23902](∅→∅),[5.23902]→[3.1860:1909](∅→∅),[3.1909]→[5.23951:24115](∅→∅),[5.23951]→[5.23951:24115](∅→∅),[5.24115]→[3.1910:2152](∅→∅),[3.2152]→[5.24349:24439](∅→∅),[5.24349]→[5.24349:24439](∅→∅),[5.24439]→[3.2153:2404](∅→∅),[3.2404]→[5.24468:24526](∅→∅),[5.24468]→[5.24468:24526](∅→∅),[5.24526]→[3.2405:2446](∅→∅),[3.2446]→[5.24567:24582](∅→∅),[5.24567]→[5.24567:24582](∅→∅)
  − c.is_leaf = hdr.is_leaf();

  −

  − let lookup = if c.is_leaf {

  − if fixed_size::<T, K, V>().is_some() {

  − let al = K::ALIGN.max(V::ALIGN);

  − let hdr_size = (HDR + al - 1) & !(al - 1);

  − let s = core::slice::from_raw_parts(

  − page.data.add(hdr_size) as *const Tuple<K, V>,

  − hdr.n() as usize,

  − );

  − if let Some(v0) = v0 {

  − s.binary_search_by(|tup| {

  − (tup.k.ord(txn), tup.v.ord(txn)).cmp(&(k0.ord(txn), v0.ord(txn)))

  − })

  − } else {

  − s.binary_search_by(|tup| {

  − (tup.k.ord(txn)).cmp(k0.ord(txn))

  − })

  − }

  − } else {

  − let s = core::slice::from_raw_parts(

  − page.data.add(HDR) as *const u16,

  − hdr.n() as usize,

  − );

  − if let Some(v0) = v0 {

  − s.binary_search_by(|&off| {

  − let off = u16::from_le(off);

  − let (k, v) = read::<T, K, V>(page.data.offset(off as isize));

  − ((&*k).ord(txn), (&*v).ord(txn)).cmp(&(k0.ord(txn), v0.ord(txn)))

  − })

  − } else {

  − s.binary_search_by(|&off| {

  − let off = u16::from_le(off);

  − let (k, _) = read::<T, K, V>(page.data.offset(off as isize));

  − ((&*k).ord(txn)).cmp(k0.ord(txn))

  − })

  − }

  − }

  − } else {

  − let s =

  − core::slice::from_raw_parts(page.data.add(HDR) as *const u64, hdr.n() as usize);

  − if let Some(v0) = v0 {

  − s.binary_search_by(|&off| {

  − let off = u64::from_le(off) & 0xfff;

  − let (k, v) = read::<T, K, V>(page.data.offset(off as isize & 0xfff));

  − ((&*k).ord(txn), (&*v).ord(txn)).cmp(&(k0.ord(txn), v0.ord(txn)))

  − })

  − } else {

  − s.binary_search_by(|&off| {

  − let off = u64::from_le(off) & 0xfff;

  − let (k, _) = read::<T, K, V>(page.data.offset(off as isize & 0xfff));

  − ((&*k).ord(txn)).cmp(k0.ord(txn))

  − })

  − }

  − };
• replacement in sanakirja-core/src/btree/page.rs at line 421
  [5.24989]→[5.24989:25086](∅→∅)
  − let off = u16::from_le(*(page.data.add(HDR + n * 2) as *const u16));
  [5.24989]

  [5.25086]
  + let off = u16::from_le(*(page.data.as_ptr().add(HDR + n * 2) as *const u16));
• replacement in sanakirja-core/src/btree/page.rs at line 424
  [5.25150]→[5.25150:25199](∅→∅)
  − Ok(Leaf::kv(*page, off))
  [5.25150]

  [5.25199]
  + Ok(Leaf::kv(page, off))
• replacement in sanakirja-core/src/btree/page.rs at line 426
  [5.25228]→[5.25228:25407](∅→∅)
  − let off = u64::from_le(*(page.data.add(HDR + n * 8) as *const u64));

  − Ok(Internal::kv(*page, (off & !0xfff, (off & 0xfff) as u16)))
  [5.25228]

  [5.25407]
  + let off = u64::from_le(*(page.data.as_ptr().add(HDR + n * 8) as *const u64));

  + Ok(Internal::kv(page, (off & !0xfff, (off & 0xfff) as u16)))
• replacement in sanakirja-core/src/btree/page.rs at line 439
  [5.25625]→[5.25625:25710](∅→∅)
  − fn split_at(_: &crate::Page, c: &Self::Cursor) -> (Self::Cursor, Self::Cursor) {
  [5.25625]

  [5.25710]
  +

  + fn split_at(_: crate::Page, c: &Self::Cursor) -> (Self::Cursor, Self::Cursor) {
• edit in sanakirja-core/src/btree/page.rs at line 461
  [5.26192]

  [5.26192]
  +

  +
• edit in sanakirja-core/src/btree/page.rs at line 464
  [5.26193]

  [5.26193]
  + unsafe fn lookup<T, K: Representable<T>, V: Representable<T>>(

  + txn: &T,

  + page: crate::Page,

  + c: &mut Cursor,

  + k0: &K,

  + v0: Option<&V>,

  + ) -> Result<usize, usize> {

  + let hdr = header(page);

  + c.total = hdr.n() as usize;

  + c.is_leaf = hdr.is_leaf();

  + if c.is_leaf {

  + if fixed_size::<T, K, V>().is_some() {

  + let al = K::ALIGN.max(V::ALIGN);

  + let hdr_size = (HDR + al - 1) & !(al - 1);

  + let s = core::slice::from_raw_parts(

  + page.data.as_ptr().add(hdr_size) as *const Tuple<K, V>,

  + hdr.n() as usize,

  + );

  + if let Some(v0) = v0 {

  + s.binary_search_by(|tup| {

  + (tup.k.ord(txn), tup.v.ord(txn)).cmp(&(k0.ord(txn), v0.ord(txn)))

  + })

  + } else {

  + s.binary_search_by(|tup| {

  + (tup.k.ord(txn)).cmp(k0.ord(txn))

  + })

  + }

  + } else {

  + let s = core::slice::from_raw_parts(

  + page.data.as_ptr().add(HDR) as *const u16,

  + hdr.n() as usize,

  + );

  + if let Some(v0) = v0 {

  + s.binary_search_by(|&off| {

  + let off = u16::from_le(off);

  + let (k, v) = read::<T, K, V>(page.data.as_ptr().offset(off as isize));

  + ((&*k).ord(txn), (&*v).ord(txn)).cmp(&(k0.ord(txn), v0.ord(txn)))

  + })

  + } else {

  + s.binary_search_by(|&off| {

  + let off = u16::from_le(off);

  + let (k, _) = read::<T, K, V>(page.data.as_ptr().offset(off as isize));

  + ((&*k).ord(txn)).cmp(k0.ord(txn))

  + })

  + }

  + }

  + } else {

  + let s =

  + core::slice::from_raw_parts(page.data.as_ptr().add(HDR) as *const u64, hdr.n() as usize);

  + if let Some(v0) = v0 {

  + s.binary_search_by(|&off| {

  + let off = u64::from_le(off) & 0xfff;

  + let (k, v) = read::<T, K, V>(page.data.as_ptr().offset(off as isize & 0xfff));

  + ((&*k).ord(txn), (&*v).ord(txn)).cmp(&(k0.ord(txn), v0.ord(txn)))

  + })

  + } else {

  + s.binary_search_by(|&off| {

  + let off = u64::from_le(off) & 0xfff;

  + let (k, _) = read::<T, K, V>(page.data.as_ptr().offset(off as isize & 0xfff));

  + ((&*k).ord(txn)).cmp(k0.ord(txn))

  + })

  + }

  + }

  + }

  +

  +

  +

  +

  +

  +

  +

  +

  +
• replacement in sanakirja-core/src/btree/page.rs at line 544
  [5.26299]→[5.26299:26386](∅→∅)
  − unsafe fn header(page: &crate::Page) -> *const Header {

  − page.data as *const Header
  [5.26299]

  [5.26386]
  + fn header<'a>(page: crate::Page<'a>) -> &'a Header {

  + unsafe {

  + &*(page.data.as_ptr() as *const Header)

  + }
• replacement in sanakirja-core/src/btree/page.rs at line 549
  [5.26388]→[5.26388:26479](∅→∅)
  − unsafe fn header_mut(page: crate::MutPage) -> *mut Header {

  − page.0.data as *mut Header
  [5.26388]

  [5.26479]
  +

  + fn header_mut(page: &mut crate::MutPage) -> &mut Header {

  + unsafe {

  + &mut *(page.0.data as *mut Header)

  + }
• replacement in sanakirja-core/src/btree/page.rs at line 557
  [5.26496]→[5.26496:26566](∅→∅)
  − unsafe fn can_alloc<T, K: Representable<T>, V: Representable<T>>(
  [5.26496]

  [5.26566]
  + fn can_alloc<T, K: Representable<T>, V: Representable<T>>(
• replacement in sanakirja-core/src/btree/page.rs at line 561
  [5.26624]→[5.26624:26696](∅→∅)
  − unsafe fn can_compact<T, K: Representable<T>, V: Representable<T>>(
  [5.26624]

  [5.26696]
  + fn can_compact<T, K: Representable<T>, V: Representable<T>>(
• replacement in sanakirja-core/src/btree/page.rs at line 565
  [5.26754]→[5.26754:26949](∅→∅)
  − unsafe fn alloc(hdr: &mut Header, size: usize, align: usize) -> u16;

  − unsafe fn alloc_insert<T, K: Representable<T>, V: Representable<T>>(

  − hdr: &mut Header,

  − new: &MutPage,
  [5.26754]

  [5.26949]
  + fn alloc(hdr: &mut Header, size: usize, align: usize) -> u16;

  +

  + // n = number of items to remove

  + fn truncate_left<T, K: Representable<T>, V: Representable<T>>(page: &mut MutPage, n: usize);

  +

  + fn alloc_insert<T, K: Representable<T>, V: Representable<T>>(

  + new: &mut MutPage,
• replacement in sanakirja-core/src/btree/page.rs at line 576
  [5.27025]→[5.27025:27156](∅→∅)
  − unsafe fn set_offset(new: MutPage, n: isize, r: u64, off: u16);

  − unsafe fn set_right_child(new: MutPage, n: isize, r: u64);
  [5.27025]

  [5.27156]
  + fn set_offset(new: &mut MutPage, n: isize, r: u64, off: u16);

  + fn set_right_child(new: &mut MutPage, n: isize, r: u64);
• replacement in sanakirja-core/src/btree/page.rs at line 579
  [5.27217]→[5.27217:27321](∅→∅)
  − unsafe fn offset_slice<'a, T, K: Representable<T>, V: Representable<T>>(

  − page: crate::Page,
  [5.27217]

  [5.27321]
  + fn offset_slice<'a, T, K: Representable<T>, V: Representable<T>>(

  + page: crate::Page<'a>,
• replacement in sanakirja-core/src/btree/page.rs at line 582
  [5.27357]→[5.27357:27424](∅→∅)
  − unsafe fn kv<'a, T, K: Representable<T>, V: Representable<T>>(
  [5.27357]

  [5.27424]
  + fn kv<'a, T, K: Representable<T>, V: Representable<T>>(
• replacement in sanakirja-core/src/btree/page.rs at line 585
  [5.27476]→[5.27476:27514](∅→∅)
  − ) -> (&'a mut K, &'a mut V, u64);
  [5.27476]

  [5.27514]
  + ) -> (&'a K, &'a V, u64);
• replacement in sanakirja-core/src/btree/page.rs at line 597
  [5.27750]→[5.27750:27785](∅→∅)
  − Offsets::Slice(s) => {
  [5.27750]

  [5.27785]
  + Offsets::Slice(s) if mid < s.len() => {

  + debug!("split_at: {:?} {:?}", s.len(), mid);
• edit in sanakirja-core/src/btree/page.rs at line 601
  [5.27886]

  [5.27886]
  + }

  + Offsets::Slice(s) => {

  + debug_assert_eq!(mid, s.len());

  + (Offsets::Slice(s), Offsets::Slice(&[][..]))
• edit in sanakirja-core/src/btree/page.rs at line 610
  [5.28060]→[5.28060:28218](∅→∅)
  − }

  − }

  − fn len(&self) -> usize {

  − match self {

  − Offsets::Slice(s) => s.len(),

  − Offsets::Range(r) => r.end - r.start,
• replacement in sanakirja-core/src/btree/page.rs at line 629
  [5.28732]→[5.28732:28802](∅→∅)
  − unsafe fn can_alloc<T, K: Representable<T>, V: Representable<T>>(
  [5.28732]

  [5.28802]
  + fn can_alloc<T, K: Representable<T>, V: Representable<T>>(
• edit in sanakirja-core/src/btree/page.rs at line 636
  [5.29015]

  [5.29015]
  + debug!("Leaf::can_alloc: {:?} {:?} {:?}", header_size, size, hdr.data);
• replacement in sanakirja-core/src/btree/page.rs at line 642
  [5.29224]→[5.29224:29296](∅→∅)
  − unsafe fn can_compact<T, K: Representable<T>, V: Representable<T>>(
  [5.29224]

  [5.29296]
  + fn can_compact<T, K: Representable<T>, V: Representable<T>>(
• replacement in sanakirja-core/src/btree/page.rs at line 655
  [5.29731]→[5.29731:29805](∅→∅)
  − unsafe fn alloc(hdr: &mut Header, size: usize, align: usize) -> u16 {
  [5.29731]

  [5.29805]
  + fn truncate_left<T, K: Representable<T>, V: Representable<T>>(page: &mut MutPage, n: usize) {

  + debug!("truncate_left {:?} {:?}", page, n);

  + if let Some(f) = fixed_size::<T, K, V>() {

  + let al = K::ALIGN.max(V::ALIGN);

  + let hdr_size = (HDR + al - 1) & !(al - 1);

  + // debug!("{:?} {:?} {:?}", new, hdr.n(), *n);

  + let hdr_n = header_mut(page).n();

  + unsafe {

  + core::ptr::copy(

  + page.0.data.add(hdr_size + n * f),

  + page.0.data.add(hdr_size),

  + n * f,

  + );

  + }

  + debug!("{:?}-{:?}", hdr_n, n);

  + let hdr = header_mut(page);

  + hdr.set_n(hdr_n - n as u16);

  + hdr.left_page = (hdr.left_page() - (n * f) as u64).to_le();

  + } else {

  + let hdr_n = header_mut(page).n();

  + unsafe {

  + core::ptr::copy(

  + page.0.data.add(HDR + n * 2),

  + page.0.data.add(HDR),

  + n * 2,

  + );

  + }

  + let deleted_offsets = unsafe {

  + core::slice::from_raw_parts(

  + page.0.data.add(HDR) as *const u16,

  + n as usize,

  + )

  + };

  + let deleted_size: u64 = deleted_offsets.iter().map(|&off| {

  + 2 + unsafe { entry_size::<T, K, V>(page.0.data.add(off as usize)) } as u64

  + }).sum();

  + let hdr = header_mut(page);

  + hdr.set_n(hdr_n - n as u16);

  + hdr.left_page = (hdr.left_page() - deleted_size).to_le();

  + }

  + }

  + fn alloc(hdr: &mut Header, size: usize, align: usize) -> u16 {
• replacement in sanakirja-core/src/btree/page.rs at line 698
  [5.29866]→[2.0:45](∅→∅)
  − data -= data & ((align - 1) as u16);
  [5.29866]

  [5.29905]
  + data &= !((align - 1) as u16);
• replacement in sanakirja-core/src/btree/page.rs at line 704
  [5.30054]→[5.30054:30176](∅→∅)
  − unsafe fn alloc_insert<T, K: Representable<T>, V: Representable<T>>(

  − hdr: &mut Header,

  − new: &MutPage,
  [5.30054]

  [5.30176]
  + fn alloc_insert<T, K: Representable<T>, V: Representable<T>>(

  + new: &mut MutPage,
• replacement in sanakirja-core/src/btree/page.rs at line 714
  [3.2506]→[5.30460:30688](∅→∅),[5.30460]→[5.30460:30688](∅→∅)
  − core::ptr::copy(

  − new.0.data.add(hdr_size + (*n as usize) * f),

  − new.0.data.add(hdr_size + (*n as usize) * f + f),

  − (hdr.n() as usize - (*n as usize)) * f,

  − );
  [3.2506]

  [5.30688]
  + let hdr_n = header_mut(new).n();

  + unsafe {

  + core::ptr::copy(

  + new.0.data.add(hdr_size + (*n as usize) * f),

  + new.0.data.add(hdr_size + (*n as usize) * f + f),

  + (hdr_n as usize - (*n as usize)) * f,

  + );

  + }

  + let hdr = header_mut(new);
• replacement in sanakirja-core/src/btree/page.rs at line 727
  [5.30848]→[5.30848:31184](∅→∅)
  − let off_new = Self::alloc(&mut *hdr, size, K::ALIGN);

  − core::ptr::copy(

  − new.0.data.add(HDR + (*n as usize) * 2),

  − new.0.data.add(HDR + (*n as usize) * 2 + 2),

  − (hdr.n() as usize - (*n as usize)) * 2,

  − );

  − Self::set_offset(*new, *n, 0, off_new);
  [5.30848]

  [5.31184]
  + let (hdr_n, off_new) = {

  + let hdr = header_mut(new);

  + (hdr.n(), Self::alloc(&mut *hdr, 2+size, K::ALIGN))

  + };

  + unsafe {

  + core::ptr::copy(

  + new.0.data.add(HDR + (*n as usize) * 2),

  + new.0.data.add(HDR + (*n as usize) * 2 + 2),

  + (hdr_n as usize - (*n as usize)) * 2,

  + );

  + }

  + Self::set_offset(new, *n, 0, off_new);
• replacement in sanakirja-core/src/btree/page.rs at line 742
  [5.31229]→[5.31229:31397](∅→∅)
  − unsafe fn set_offset(new: MutPage, n: isize, _: u64, off: u16) {

  − let ptr = new.0.data.offset(HDR as isize + n * 2) as *mut u16;

  − *ptr = off.to_le();
  [5.31229]

  [5.31397]
  + fn set_offset(new: &mut MutPage, n: isize, _: u64, off: u16) {

  + unsafe {

  + let ptr = new.0.data.offset(HDR as isize + n * 2) as *mut u16;

  + *ptr = off.to_le();

  + }
• replacement in sanakirja-core/src/btree/page.rs at line 748
  [5.31403]→[5.31403:31466](∅→∅)
  − unsafe fn set_right_child(_: MutPage, _: isize, _: u64) {}
  [5.31403]

  [5.31466]
  + fn set_right_child(_: &mut MutPage, _: isize, _: u64) {}
• replacement in sanakirja-core/src/btree/page.rs at line 750
  [5.31496]→[5.31496:31600](∅→∅)
  − unsafe fn offset_slice<'a, T, K: Representable<T>, V: Representable<T>>(

  − page: crate::Page,
  [5.31496]

  [5.31600]
  +

  + fn offset_slice<'a, T, K: Representable<T>, V: Representable<T>>(

  + page: crate::Page<'a>,
• replacement in sanakirja-core/src/btree/page.rs at line 754
  [5.31637]→[5.31637:31672](∅→∅)
  − let hdr = &*header(&page);
  [5.31637]

  [5.31672]
  + let hdr = header(page);
• replacement in sanakirja-core/src/btree/page.rs at line 758
  [5.31786]→[5.31786:31948](∅→∅)
  − Offsets::Slice(core::slice::from_raw_parts(

  − page.data.add(HDR) as *const LeafOffset,

  − hdr.n() as usize,

  − ))
  [5.31786]

  [5.31948]
  + unsafe {

  + Offsets::Slice(core::slice::from_raw_parts(

  + page.data.as_ptr().add(HDR) as *const LeafOffset,

  + hdr.n() as usize,

  + ))

  + }
• replacement in sanakirja-core/src/btree/page.rs at line 766
  [5.31964]→[5.31964:32031](∅→∅)
  − unsafe fn kv<'a, T, K: Representable<T>, V: Representable<T>>(
  [5.31964]

  [5.32031]
  + fn kv<'a, T, K: Representable<T>, V: Representable<T>>(
• replacement in sanakirja-core/src/btree/page.rs at line 769
  [5.32088]→[5.32088:32224](∅→∅)
  − ) -> (&'a mut K, &'a mut V, u64) {

  − let (k, v) = read::<T, K, V>(page.data.add(off as usize));

  − (&mut *k, &mut *v, 0)
  [5.32088]

  [5.32224]
  + ) -> (&'a K, &'a V, u64) {

  + unsafe {

  + let (k, v) = read::<T, K, V>(page.data.as_ptr().add(off as usize));

  + (& *k, & *v, 0)

  + }
• replacement in sanakirja-core/src/btree/page.rs at line 778
  [5.32259]→[5.32259:32329](∅→∅)
  − unsafe fn can_alloc<T, K: Representable<T>, V: Representable<T>>(
  [5.32259]

  [5.32329]
  + fn can_alloc<T, K: Representable<T>, V: Representable<T>>(
• edit in sanakirja-core/src/btree/page.rs at line 782
  [5.32388]

  [5.32388]
  + debug!("Internal::can_alloc: {:?} {:?}", hdr.n(), hdr.data);
• replacement in sanakirja-core/src/btree/page.rs at line 785
  [5.32487]→[5.32487:32559](∅→∅)
  − unsafe fn can_compact<T, K: Representable<T>, V: Representable<T>>(
  [5.32487]

  [5.32559]
  + fn can_compact<T, K: Representable<T>, V: Representable<T>>(
• replacement in sanakirja-core/src/btree/page.rs at line 791
  [5.32704]→[5.32704:32778](∅→∅)
  − unsafe fn alloc(hdr: &mut Header, size: usize, align: usize) -> u16 {
  [5.32704]

  [5.32778]
  + fn truncate_left<T, K: Representable<T>, V: Representable<T>>(page: &mut MutPage, n: usize) {

  + // The following line copies the left child of the last entry

  + // (hence the `- 8` and `- 1`)

  + unsafe {

  + core::ptr::copy(

  + page.0.data.add(HDR + (n - 1) * 8),

  + page.0.data.add(HDR - 8),

  + (n + 1) * 8,

  + );

  + }

  + let hdr_n = header_mut(page).n();

  + let size = if let Some(f) = fixed_size::<T, K, V>() {

  + ((8 + f) * (hdr_n as usize - n)) as u64

  + } else {

  + let offsets = unsafe {

  + core::slice::from_raw_parts(

  + page.0.data.add(HDR + n * 8) as *const u16,

  + hdr_n as usize - n as usize,

  + )

  + };

  + offsets.iter().map(|&off| {

  + 8 + unsafe { entry_size::<T, K, V>(page.0.data.add(off as usize)) } as u64

  + }).sum()

  + };

  + let hdr = header_mut(page);

  + hdr.set_n(hdr_n - n as u16);

  + hdr.left_page = ((hdr.left_page() & !0xfff) | size).to_le();

  +

  + }

  + fn alloc(hdr: &mut Header, size: usize, align: usize) -> u16 {

  + debug!("data = {:?}, size = {:?}", hdr.data, size);
• replacement in sanakirja-core/src/btree/page.rs at line 829
  [5.33027]→[5.33027:33149](∅→∅)
  − unsafe fn alloc_insert<T, K: Representable<T>, V: Representable<T>>(

  − hdr: &mut Header,

  − new: &MutPage,
  [5.33027]

  [5.33149]
  + fn alloc_insert<T, K: Representable<T>, V: Representable<T>>(

  + new: &mut MutPage,
• replacement in sanakirja-core/src/btree/page.rs at line 835
  [5.33226]→[5.33226:33548](∅→∅)
  − let off_new = Self::alloc(&mut *hdr, size, K::ALIGN.max(V::ALIGN));

  − core::ptr::copy(

  − new.0.data.add(HDR + (*n as usize) * 8),

  − new.0.data.add(HDR + (*n as usize) * 8 + 8),

  − (hdr.n() as usize - (*n as usize)) * 8,

  − );

  − Self::set_offset(*new, *n, r, off_new);
  [5.33226]

  [5.33548]
  + let (hdr_n, off_new) = {

  + let hdr = header_mut(new);

  + (hdr.n(), Self::alloc(&mut *hdr, size, K::ALIGN.max(V::ALIGN)))

  + };

  + unsafe {

  + core::ptr::copy(

  + new.0.data.add(HDR + (*n as usize) * 8),

  + new.0.data.add(HDR + (*n as usize) * 8 + 8),

  + (hdr_n as usize - (*n as usize)) * 8,

  + );

  + }

  + Self::set_offset(new, *n, r, off_new);
• replacement in sanakirja-core/src/btree/page.rs at line 849
  [5.33579]→[5.33579:33760](∅→∅)
  − unsafe fn set_offset(new: MutPage, n: isize, r: u64, off: u16) {

  − let ptr = new.0.data.offset(HDR as isize + n * 8) as *mut u64;

  − *ptr = (r | off as u64).to_le();
  [5.33579]

  [5.33760]
  + fn set_offset(new: &mut MutPage, n: isize, r: u64, off: u16) {

  + unsafe {

  + let ptr = new.0.data.offset(HDR as isize + n * 8) as *mut u64;

  + *ptr = (r | off as u64).to_le();

  + }
• replacement in sanakirja-core/src/btree/page.rs at line 855
  [5.33766]→[5.33766:33990](∅→∅)
  − unsafe fn set_right_child(page: MutPage, n: isize, r: u64) {

  − let ptr = page.0.data.offset(HDR as isize + n * 8) as *mut u64;

  − let off = u64::from_le(*ptr) & 0xfff;

  − *ptr = (r | off as u64).to_le();
  [5.33766]

  [5.33990]
  + fn set_right_child(page: &mut MutPage, n: isize, r: u64) {

  + unsafe {

  + let ptr = page.0.data.offset(HDR as isize + n * 8) as *mut u64;

  + let off = u64::from_le(*ptr) & 0xfff;

  + *ptr = (r | off as u64).to_le();

  + }
• replacement in sanakirja-core/src/btree/page.rs at line 863
  [5.34030]→[5.34030:34134](∅→∅)
  − unsafe fn offset_slice<'a, T, K: Representable<T>, V: Representable<T>>(

  − page: crate::Page,
  [5.34030]

  [5.34134]
  +

  + fn offset_slice<'a, T, K: Representable<T>, V: Representable<T>>(

  + page: crate::Page<'a>,
• replacement in sanakirja-core/src/btree/page.rs at line 867
  [5.34171]→[5.34171:34356](∅→∅)
  − let hdr = &*header(&page);

  − Offsets::Slice(core::slice::from_raw_parts(

  − page.data.add(HDR) as *const InternalOffset,

  − hdr.n() as usize,

  − ))
  [5.34171]

  [5.34356]
  + let hdr = header(page);

  + unsafe {

  + Offsets::Slice(core::slice::from_raw_parts(

  + page.data.as_ptr().add(HDR) as *const InternalOffset,

  + hdr.n() as usize,

  + ))

  + }
• replacement in sanakirja-core/src/btree/page.rs at line 875
  [5.34362]→[5.34362:34429](∅→∅)
  − unsafe fn kv<'a, T, K: Representable<T>, V: Representable<T>>(
  [5.34362]

  [5.34429]
  + fn kv<'a, T, K: Representable<T>, V: Representable<T>>(
• replacement in sanakirja-core/src/btree/page.rs at line 878
  [5.34486]→[5.34486:34622](∅→∅)
  − ) -> (&'a mut K, &'a mut V, u64) {

  − let (k, v) = read::<T, K, V>(page.data.add(off as usize));

  − (&mut *k, &mut *v, r)
  [5.34486]

  [5.34622]
  + ) -> (&'a K, &'a V, u64) {

  + unsafe {

  + let (k, v) = read::<T, K, V>(page.data.as_ptr().add(off as usize));

  + (& *k, & *v, r)

  + }
• replacement in sanakirja-core/src/btree/page.rs at line 887
  [5.34714]→[5.34714:34732](∅→∅)
  − new: MutPage,
  [5.34714]

  [5.34732]
  + new: &mut MutPage,
• replacement in sanakirja-core/src/btree/page.rs at line 891
  [5.34802]→[5.34802:35024](∅→∅)
  − let hdr = &mut *header_mut(new);

  − let mut l = <Page<K, V>>::left_child(&m.page, &m.c0);

  − while let Some((k, v, r)) = <Page<K, V>>::next(&m.page, &mut m.c0) {

  − alloc::<_, _, _, L>(hdr, new, k, v, l, r, n);
  [5.34802]

  [5.35024]
  + let mut l = <Page<K, V>>::left_child(m.page.as_page(), &m.c0);

  + while let Some((k, v, r)) = <Page<K, V>>::next(m.page.as_page(), &mut m.c0) {

  + alloc::<_, _, _, L>(new, k, v, l, r, n);
• replacement in sanakirja-core/src/btree/page.rs at line 897
  [5.35082]→[5.35082:35142](∅→∅)
  − alloc::<_, _, _, L>(hdr, new, &*k, &*v, m.l, r, n);
  [5.35082]

  [5.35142]
  + alloc::<_, _, _, L>(new, &*k, &*v, m.l, r, n);
• replacement in sanakirja-core/src/btree/page.rs at line 902
  [5.35214]→[5.35214:35287](∅→∅)
  − while let Some((k, v, r)) = <Page<K, V>>::next(&m.page, &mut m.c1) {
  [5.35214]

  [5.35287]
  + while let Some((k, v, r)) = <Page<K, V>>::next(m.page.as_page(), &mut m.c1) {
• replacement in sanakirja-core/src/btree/page.rs at line 907
  [5.35371]→[5.35371:35425](∅→∅)
  − alloc::<_, _, _, L>(hdr, new, k, v, l, r, n);
  [5.35371]

  [5.35425]
  + alloc::<_, _, _, L>(new, k, v, l, r, n);
• replacement in sanakirja-core/src/btree/page.rs at line 913
  [5.35531]→[5.35531:35549](∅→∅)
  − new: MutPage,
  [5.35531]

  [5.35549]
  + new: &mut MutPage,
• edit in sanakirja-core/src/btree/page.rs at line 916
  [5.35594]→[5.35594:35631](∅→∅)
  − let hdr = &mut *header_mut(new);
• replacement in sanakirja-core/src/btree/page.rs at line 918
  [5.35673]→[5.35673:36058](∅→∅)
  − modify::<_, _, _, L>(new, m.modified, &mut n);

  − let mut rc = <Page<K, V>>::first_cursor(&m.other);

  − let l = <Page<K, V>>::left_child(&m.other, &rc);

  − alloc::<_, _, _, L>(hdr, new, &*m.mid.0, &*m.mid.1, 0, l, &mut n);

  − while let Some((k, v, r)) = <Page<K, V>>::next(&m.other, &mut rc) {

  − alloc::<_, _, _, L>(hdr, new, k, v, 0, r, &mut n);
  [5.35673]

  [5.36058]
  + modify::<_, _, _, L>(new, &mut m.modified, &mut n);

  + let mut rc = <Page<K, V>>::first_cursor(m.other.as_page());

  + let l = <Page<K, V>>::left_child(m.other.as_page(), &rc);

  + alloc::<_, _, _, L>(new, &*m.mid.0, &*m.mid.1, 0, l, &mut n);

  + while let Some((k, v, r)) = <Page<K, V>>::next(m.other.as_page(), &mut rc) {

  + alloc::<_, _, _, L>(new, k, v, 0, r, &mut n);
• replacement in sanakirja-core/src/btree/page.rs at line 926
  [5.36081]→[5.36081:36340](∅→∅)
  − let mut rc = <Page<K, V>>::first_cursor(&m.other);

  − let mut l = <Page<K, V>>::left_child(&m.other, &rc);

  − while let Some((k, v, r)) = <Page<K, V>>::next(&m.other, &mut rc) {

  − alloc::<_, _, _, L>(hdr, new, k, v, l, r, &mut n);
  [5.36081]

  [5.36340]
  + let mut rc = <Page<K, V>>::first_cursor(m.other.as_page());

  + let mut l = <Page<K, V>>::left_child(m.other.as_page(), &rc);

  + while let Some((k, v, r)) = <Page<K, V>>::next(m.other.as_page(), &mut rc) {

  + alloc::<_, _, _, L>(new, k, v, l, r, &mut n);
• replacement in sanakirja-core/src/btree/page.rs at line 932
  [5.36369]→[5.36369:36499](∅→∅)
  − alloc::<_, _, _, L>(hdr, new, &*m.mid.0, &*m.mid.1, 0, 0, &mut n);

  − modify::<_, _, _, L>(new, m.modified, &mut n);
  [5.36369]

  [5.36499]
  + alloc::<_, _, _, L>(new, &*m.mid.0, &*m.mid.1, 0, 0, &mut n);

  + modify::<_, _, _, L>(new, &mut m.modified, &mut n);
• replacement in sanakirja-core/src/btree/page.rs at line 937
  [5.36508]→[5.36508:36599](∅→∅)
  − unsafe fn rebalance<'a, T: AllocPage, K: Representable<T>, V: Representable<T>, L: Alloc>(
  [5.36508]

  [5.36599]
  + fn rebalance<'a, T: AllocPage, K: Representable<T>, V: Representable<T>, L: Alloc>(
• replacement in sanakirja-core/src/btree/page.rs at line 939
  [5.36616]→[5.36616:36657](∅→∅)
  − m: &mut Concat<T, K, V, Page<K, V>>,
  [5.36616]

  [5.36657]
  + m: &mut Concat<'a, T, K, V, Page<K, V>>,
• replacement in sanakirja-core/src/btree/page.rs at line 941
  [5.36698]→[5.36698:36871](∅→∅)
  − let rc = <Page<K, V>>::first_cursor(&m.other);

  − let rl = <Page<K, V>>::left_child(&m.other, &rc);

  − let (k, v, r) = <Page<K, V>>::unchecked_current(&m.other, &rc);
  [5.36698]

  [5.36871]
  + let rc = <Page<K, V>>::first_cursor(m.other.as_page());

  + let rl = <Page<K, V>>::left_child(m.other.as_page(), &rc);

  + let (k, v, r) = unsafe { <Page<K, V>>::unchecked_current(m.other.as_page(), &rc) };
• edit in sanakirja-core/src/btree/page.rs at line 945
  [5.36872]→[5.36872:36914](∅→∅)
  − let hdr = &*header(&m.modified.page);
• replacement in sanakirja-core/src/btree/page.rs at line 946
  [5.36942]→[5.36942:37068](∅→∅)
  − let new_left = if hdr.is_dirty() {

  − let page = MutPage(m.modified.page);

  − let hdr = &mut *header_mut(page);
  [5.36942]

  [5.37068]
  + let new_left = if header(m.modified.page.as_page()).is_dirty() {

  + let mut page = unsafe { core::mem::transmute(m.modified.page) };
• replacement in sanakirja-core/src/btree/page.rs at line 949
  [5.37118]→[5.37118:37195](∅→∅)
  − alloc::<T, K, V, L>(hdr, page, &*m.mid.0, &*m.mid.1, 0, rl, &mut n);
  [5.37118]

  [5.37195]
  + alloc::<T, K, V, L>(&mut page, m.mid.0, m.mid.1, 0, rl, &mut n);
• replacement in sanakirja-core/src/btree/page.rs at line 952
  [5.37221]→[5.37221:37418](∅→∅)
  − let new = txn.alloc_page()?;

  − <Page<K, V> as BTreeMutPage<T, K, V>>::init(new);

  − let s = L::offset_slice::<T, K, V>(m.modified.page);

  − let hdr = &mut *header_mut(new);
  [5.37221]

  [5.37418]
  + let mut new = txn.alloc_page()?;

  + <Page<K, V> as BTreeMutPage<T, K, V>>::init(&mut new);

  + let s = L::offset_slice::<T, K, V>(m.modified.page.as_page());
• replacement in sanakirja-core/src/btree/page.rs at line 956
  [5.37441]→[5.37441:37636](∅→∅)
  − clone::<T, K, V, L>(hdr, m.modified.page, new, s, &mut n);

  − alloc::<T, K, V, L>(hdr, new, &*m.mid.0, &*m.mid.1, 0, rl, &mut n);

  − let b = if hdr.is_dirty() { 1 } else { 0 };
  [5.37441]

  [5.37636]
  + clone::<T, K, V, L>(m.modified.page.as_page(), &mut new, s, &mut n);

  + alloc::<T, K, V, L>(&mut new, m.mid.0, m.mid.1, 0, rl, &mut n);

  +

  + let b = if header(m.modified.page.as_page()).is_dirty() { 1 } else { 0 };
• replacement in sanakirja-core/src/btree/page.rs at line 965
  [5.37810]→[5.37810:37848](∅→∅)
  − let hdr = &*header(&m.other);
  [5.37810]

  [5.37848]
  + let hdr = &*header(m.other.as_page());
• replacement in sanakirja-core/src/btree/page.rs at line 972
  [5.38029]→[5.38029:38051](∅→∅)
  − k,

  − v,
  [5.38029]

  [5.38051]
  + k: unsafe { core::mem::transmute(k) },

  + v: unsafe { core::mem::transmute(v) },
• replacement in sanakirja-core/src/btree/page.rs at line 1010
  [5.38647]→[5.38647:38741](∅→∅)
  − unsafe fn clone<T, K: Representable<T>, V: Representable<T>, L: Alloc>(

  − hdr: &mut Header,
  [5.38647]

  [5.38741]
  + fn clone<T, K: Representable<T>, V: Representable<T>, L: Alloc>(
• replacement in sanakirja-core/src/btree/page.rs at line 1012
  [5.38764]→[5.38764:38782](∅→∅)
  − new: MutPage,
  [5.38764]

  [5.38782]
  + new: &mut MutPage,
• replacement in sanakirja-core/src/btree/page.rs at line 1020
  [5.38969]→[5.38969:39339](∅→∅)
  − let off = u16::from_le(off);

  − let ptr = page.data.add(off as usize);

  − let size = entry_size::<T, K, V>(ptr);

  − let off_new = L::alloc(&mut *hdr, size, K::ALIGN);

  − core::ptr::copy_nonoverlapping(ptr, new.0.data.offset(off_new as isize), size);

  − L::set_offset(new, *n, r, off_new);
  [5.38969]

  [5.39339]
  + debug!("clone: {:?} {:?}", r, off);

  + unsafe {

  + let ptr = page.data.as_ptr().add(off as usize);

  + let size = entry_size::<T, K, V>(ptr);

  + debug!("size: {:?}", size);

  + let hdr = header_mut(new);

  + let off_new = L::alloc(hdr, size, K::ALIGN);

  + debug!("off_new: {:?}", off_new);

  + core::ptr::copy_nonoverlapping(ptr, new.0.data.offset(off_new as isize), size);

  + L::set_offset(new, *n, r, off_new);

  + }
• edit in sanakirja-core/src/btree/page.rs at line 1038
  [5.39576]

  [5.39576]
  + let len = r.len();
• replacement in sanakirja-core/src/btree/page.rs at line 1040
  [5.39603]→[5.39603:39933](∅→∅)
  − let ptr = page.data.add(header_size + off * size);

  − let new_ptr = new.0.data.add(header_size + (*n as usize) * size);

  − core::ptr::copy_nonoverlapping(ptr, new_ptr, size);

  − hdr.set_n(hdr.n() + 1);

  − hdr.left_page = (hdr.left_page() + size as u64).to_le();
  [5.39603]

  [5.39933]
  + unsafe {

  + let ptr = page.data.as_ptr().add(header_size + off * size);

  + let new_ptr = new.0.data.add(header_size + (*n as usize) * size);

  + core::ptr::copy_nonoverlapping(ptr, new_ptr, size);

  + }
• edit in sanakirja-core/src/btree/page.rs at line 1047
  [5.39972]

  [5.39972]
  + let hdr = header_mut(new);

  + hdr.set_n(hdr.n() + len as u16);

  + hdr.left_page = (hdr.left_page() + (size * len) as u64).to_le();
• replacement in sanakirja-core/src/btree/page.rs at line 1054
  [5.39991]→[5.39991:40103](∅→∅)
  − unsafe fn alloc<T, K: Representable<T>, V: Representable<T>, L: Alloc>(

  − hdr: &mut Header,

  − new: MutPage,
  [5.39991]

  [5.40103]
  + fn alloc<T, K: Representable<T>, V: Representable<T>, L: Alloc>(

  + new: &mut MutPage,
• replacement in sanakirja-core/src/btree/page.rs at line 1063
  [5.40209]→[5.40209:40544](∅→∅)
  − let off_new = L::alloc_insert::<T, K, V>(hdr, &new, n, size, r);

  − let new_ptr = new.0.data.add(off_new as usize);

  − core::ptr::copy_nonoverlapping(k0, new_ptr as *mut K, 1);

  − let ks = k0.size();

  − let v_ptr = new_ptr.add((ks + V::ALIGN - 1) & !(V::ALIGN - 1));

  − core::ptr::copy_nonoverlapping(v0, v_ptr as *mut V, 1);
  [5.40209]

  [5.40544]
  + let off_new = L::alloc_insert::<T, K, V>(new, n, size, r);

  + unsafe {

  + let new_ptr = new.0.data.add(off_new as usize);

  + core::ptr::copy_nonoverlapping(k0, new_ptr as *mut K, 1);

  + let ks = k0.size();

  + let v_ptr = new_ptr.add((ks + V::ALIGN - 1) & !(V::ALIGN - 1));

  + core::ptr::copy_nonoverlapping(v0, v_ptr as *mut V, 1);

  + }
• replacement in sanakirja-core/src/btree/page.rs at line 1077
  [5.40625]→[5.40625:40710](∅→∅)
  − unsafe fn put<'a, T: AllocPage, K: Representable<T>, V: Representable<T>, L: Alloc>(
  [5.40625]

  [5.40710]
  + fn put<'a, T: AllocPage, K: Representable<T>, V: Representable<T>, L: Alloc>(
• replacement in sanakirja-core/src/btree/page.rs at line 1079
  [5.40727]→[5.40727:40750](∅→∅)
  − page: crate::Page,
  [5.40727]

  [5.40750]
  + page: CowPage,
• replacement in sanakirja-core/src/btree/page.rs at line 1088
  [5.40911]→[5.40911:41103](∅→∅)
  − let hdr = &*header(&page);

  − if mutable && hdr.is_dirty() && L::can_alloc::<T, K, V>(&*header(&page), size) {

  − let page = MutPage(page);

  − let hdr = &mut *header_mut(page);
  [5.40911]

  [5.41103]
  + let hdr = header(page.as_page());

  + let is_dirty = hdr.is_dirty();

  + debug!("put {:?} {:?} {:?}", u, mutable, is_dirty);

  + if mutable && is_dirty && L::can_alloc::<T, K, V>(header(page.as_page()), size) {

  + debug!("can alloc");

  + let mut page = unsafe { core::mem::transmute(page) };
• replacement in sanakirja-core/src/btree/page.rs at line 1095
  [5.41135]→[5.41135:41197](∅→∅)
  − alloc::<_, _, _, L>(hdr, page, k0, v0, l, r, &mut n);
  [5.41135]

  [5.41197]
  + alloc::<_, _, _, L>(&mut page, k0, v0, l, r, &mut n);
• replacement in sanakirja-core/src/btree/page.rs at line 1098
  [5.41293]→[5.41293:41438](∅→∅)
  − let new = txn.alloc_page()?;

  − <Page<K, V> as BTreeMutPage<T, K, V>>::init(new);

  − let s = L::offset_slice::<T, K, V>(page);
  [5.41293]

  [5.41438]
  + let mut new = txn.alloc_page()?;

  + debug!("can compact: {:?}", new);

  + <Page<K, V> as BTreeMutPage<T, K, V>>::init(&mut new);

  + L::set_right_child(&mut new, -1, hdr.left_page & !0xfff);

  + let s = L::offset_slice::<T, K, V>(page.as_page());
• edit in sanakirja-core/src/btree/page.rs at line 1104
  [5.41485]→[5.41485:41526](∅→∅)
  − let hdr = &mut *header_mut(new);
• replacement in sanakirja-core/src/btree/page.rs at line 1105
  [5.41549]→[5.41549:41777](∅→∅)
  − clone::<T, K, V, L>(hdr, page, new, s0, &mut n);

  − alloc::<T, K, V, L>(hdr, new, k0, v0, l, r, &mut n);

  − clone::<T, K, V, L>(hdr, page, new, s1, &mut n);

  − let b0 = if hdr.is_dirty() { 1 } else { 0 };
  [5.41549]

  [5.41777]
  + clone::<T, K, V, L>(page.as_page(), &mut new, s0, &mut n);

  + alloc::<T, K, V, L>(&mut new, k0, v0, l, r, &mut n);

  + clone::<T, K, V, L>(page.as_page(), &mut new, s1, &mut n);

  +

  + let b0 = if is_dirty { 1 } else { 0 };
• edit in sanakirja-core/src/btree/page.rs at line 1115
  [5.41894]

  [5.41894]
  + debug!("split");
• replacement in sanakirja-core/src/btree/page.rs at line 1119
  [5.42042]→[5.42042:42127](∅→∅)
  − return split_unsized::<_, _, _, L>(txn, page, mutable, u, k0, v0, l, r);
  [5.42042]

  [5.42127]
  + return split_unsized::<_, _, _, L>(txn, page.as_page(), mutable, u, k0, v0, l, r);
• replacement in sanakirja-core/src/btree/page.rs at line 1124
  [5.42146]→[5.42146:42233](∅→∅)
  − unsafe fn split<'a, T: AllocPage, K: Representable<T>, V: Representable<T>, L: Alloc>(
  [5.42146]

  [5.42233]
  + fn split<'a, T: AllocPage, K: Representable<T>, V: Representable<T>, L: Alloc>(
• replacement in sanakirja-core/src/btree/page.rs at line 1126
  [5.42250]→[5.42250:42273](∅→∅)
  − page: crate::Page,
  [5.42250]

  [5.42273]
  + page: CowPage,
• replacement in sanakirja-core/src/btree/page.rs at line 1135
  [5.42416]→[5.42416:42552](∅→∅)
  − let left;

  − let right = txn.alloc_page()?;

  − <Page<K, V> as BTreeMutPage<T, K, V>>::init(right);

  − let hdr = &*header(&page);
  [5.42416]

  [5.42552]
  + let mut left;

  + let hdr = header(page.as_page());
• replacement in sanakirja-core/src/btree/page.rs at line 1142
  [5.42704]→[4.52:98](∅→∅)
  − let s = L::offset_slice::<T, K, V>(page);
  [5.42704]

  [5.42731]
  + let s = L::offset_slice::<T, K, V>(page.as_page());
• replacement in sanakirja-core/src/btree/page.rs at line 1149
  [5.43024]→[5.43024:43085](∅→∅)
  − let (k, v, r) = L::kv(page, s1a.first::<T, K, V>());
  [5.43024]

  [5.43085]
  + let (k, v, r) = L::kv(page.as_page(), s1a.first::<T, K, V>());
• replacement in sanakirja-core/src/btree/page.rs at line 1153
  [5.43142]→[5.43142:43517](∅→∅)
  − if mutable && hdr.is_dirty() && u >= k as usize {

  − // (k0, v0) is to be inserted on the right-hand side of

  − // the split, hence we don't have to clone the left-hand

  − // side, we can just truncate it.

  − let hdr = &mut *header_mut(MutPage(page));

  − left = MutPage(page);

  − hdr.set_n(k);

  − hdr.decr((n - 1 - k) as usize * size);
  [5.43142]

  [5.43517]
  + if u >= k as usize {

  + if mutable && hdr.is_dirty() {

  + debug!("mutable dirty {:?} >= {:?}", u, k);

  + // (k0, v0) is to be inserted on the right-hand side of

  + // the split, hence we don't have to clone the left-hand

  + // side, we can just truncate it.

  + left = unsafe { core::mem::transmute(page) };

  + let hdr = header_mut(&mut left);

  + hdr.set_n(k);

  + hdr.decr((n - 1 - k) as usize * size);

  + } else {

  + left = txn.alloc_page()?;

  + debug!("immutable {:?} >= {:?}", u, k);

  + let mut n = 0;

  + clone::<T, K, V, L>(page.as_page(), &mut left, s0, &mut n);

  + freed = page.offset | page_is_dirty

  + }

  + // If we are here, u >= k, i.e. the insertion is in the right-hand

  + // side of the split.

  + let mut n = 0;

  + let mut right = txn.alloc_page()?;

  + <Page<K, V> as BTreeMutPage<T, K, V>>::init(&mut right);

  + if u > k as usize {

  + let kk = u as usize - k as usize - 1;

  + let (s1a, s1b) = s1.split_at(kk);

  + L::set_right_child(&mut right, -1, mid_child);

  + clone::<T, K, V, L>(page.as_page(), &mut right, s1a, &mut n);

  + alloc::<T, K, V, L>(&mut right, k0, v0, l, r, &mut n);

  + clone::<T, K, V, L>(page.as_page(), &mut right, s1b, &mut n);

  + } else {

  + // Insertion in the middle.

  + L::set_right_child(&mut right, -1, mid_child);

  + clone::<T, K, V, L>(page.as_page(), &mut right, s1, &mut n);

  + }

  + Ok(Put::Split {

  + split_key,

  + split_value,

  + left,

  + right,

  + freed,

  + })
• replacement in sanakirja-core/src/btree/page.rs at line 1196
  [5.43564]→[5.43564:43724](∅→∅),[5.43724]→[4.99:208](∅→∅),[4.208]→[5.43791:44378](∅→∅),[5.43791]→[5.43791:44378](∅→∅)
  − <Page<K, V> as BTreeMutPage<T, K, V>>::init(left);

  − if u < k as usize {

  − let mut n = 0;

  − let hdr = &mut *header_mut(left);

  − // debug!("{:?} {:?}", u, k);

  − let (s0a, s0b) = s1.split_at(k as usize - u as usize);

  − clone::<T, K, V, L>(hdr, page, left, s0a, &mut n);

  − alloc::<T, K, V, L>(hdr, left, k0, v0, r, l, &mut n);

  − clone::<T, K, V, L>(hdr, page, left, s0b, &mut n);

  − let hdr = &mut *header_mut(right);

  − let mut n = 0;

  − L::set_right_child(right, -1, mid_child);

  − clone::<T, K, V, L>(hdr, page, right, s1, &mut n);

  − return Ok(Put::Split {

  − split_key,

  − split_value,

  − left,

  − right,

  − freed: page.offset | page_is_dirty,

  − });
  [5.43564]

  [5.44378]
  + <Page<K, V> as BTreeMutPage<T, K, V>>::init(&mut left);

  + debug!("{:?} < {:?}", u, k);

  + let mut n = 0;

  + let mid = k as usize - u as usize;

  + let (s0a, s0b) = s0.split_at(mid);

  + clone::<T, K, V, L>(page.as_page(), &mut left, s0a, &mut n);

  + alloc::<T, K, V, L>(&mut left, k0, v0, r, l, &mut n);

  + clone::<T, K, V, L>(page.as_page(), &mut left, s0b, &mut n);

  +

  + let mut right: MutPage;

  + let freed;

  +

  + if mutable && hdr.is_dirty() {

  + right = unsafe { core::mem::transmute(page) };

  + L::truncate_left::<T, K, V>(&mut right, k as usize);

  + freed = 0;
• replacement in sanakirja-core/src/btree/page.rs at line 1213
  [5.44395]→[5.44395:44441](∅→∅)
  − let hdr = &mut *header_mut(left);
  [5.44395]

  [5.44441]
  + right = txn.alloc_page()?;

  + <Page<K, V> as BTreeMutPage<T, K, V>>::init(&mut right);
• replacement in sanakirja-core/src/btree/page.rs at line 1216
  [5.44468]→[5.44468:44530](∅→∅)
  − clone::<T, K, V, L>(hdr, page, left, s0, &mut n);
  [5.44468]

  [5.44530]
  + L::set_right_child(&mut right, -1, mid_child);

  + clone::<T, K, V, L>(page.as_page(), &mut right, s1, &mut n);
• edit in sanakirja-core/src/btree/page.rs at line 1220
  [5.44588]

  [5.44588]
  + Ok(Put::Split {

  + split_key,

  + split_value,

  + left,

  + right,

  + freed,

  + })
• edit in sanakirja-core/src/btree/page.rs at line 1228
  [5.44594]→[5.44594:44826](∅→∅),[5.44874]→[5.44874:44956](∅→∅),[5.45003]→[5.45003:45049](∅→∅),[5.45088]→[5.45088:45144](∅→∅),[5.45173]→[5.45173:45232](∅→∅),[5.45263]→[5.45263:45430](∅→∅)
  − // If we are here, u > k, i.e. the insertion is in the right-hand

  − // side of the split.

  − let hdr = &mut *header_mut(right);

  − let mut n = 0;

  − let kk = u as usize - k as usize;

  − let (s1a, s1b) = if kk < s1.len() {

  − s1.split_at(kk)

  − } else {

  − (s1, Offsets::Slice(&[][..]))

  − };

  − L::set_right_child(right, -1, mid_child);

  − clone::<T, K, V, L>(hdr, page, right, s1a, &mut n);

  − alloc::<T, K, V, L>(hdr, right, k0, v0, l, r, &mut n);

  − clone::<T, K, V, L>(hdr, page, right, s1b, &mut n);

  − Ok(Put::Split {

  − split_key,

  − split_value,

  − left,

  − right,

  − freed,

  − })
• replacement in sanakirja-core/src/btree/page.rs at line 1230
  [5.45433]→[5.45433:45528](∅→∅)
  − unsafe fn split_unsized<'a, T: AllocPage, K: Representable<T>, V: Representable<T>, L: Alloc>(
  [5.45433]

  [5.45528]
  + fn split_unsized<'a, T: AllocPage, K: Representable<T>, V: Representable<T>, L: Alloc>(
• replacement in sanakirja-core/src/btree/mod.rs at line 30
  [5.46263]→[5.46263:46660](∅→∅)
  − fn first_cursor(p: &Page) -> Self::Cursor;

  − fn last_cursor(p: &Page) -> Self::Cursor;

  − fn next<'b>(p: &Page, c: &mut Self::Cursor) -> Option<(&'b mut K, &'b mut V, u64)> {

  − unsafe {

  − if let Some((k, v, r)) = Self::current(p, c) {

  − Self::move_next(p, c);

  − Some((&mut *k, &mut *v, r))

  − } else {

  − None

  − }
  [5.46263]

  [5.46660]
  + fn first_cursor(p: Page) -> Self::Cursor;

  + fn last_cursor(p: Page) -> Self::Cursor;

  + fn next<'b>(p: Page<'b>, c: &mut Self::Cursor) -> Option<(&'b K, &'b V, u64)> {

  + if let Some((k, v, r)) = Self::current(p, c) {

  + Self::move_next(p, c);

  + Some((k, v, r))

  + } else {

  + None
• replacement in sanakirja-core/src/btree/mod.rs at line 40
  [5.46676]→[5.46676:46909](∅→∅)
  − fn move_next<'b>(p: &Page, c: &mut Self::Cursor) -> bool;

  − unsafe fn unchecked_current(p: &Page, c: &Self::Cursor) -> (*mut K, *mut V, u64);

  − unsafe fn current(p: &Page, c: &Self::Cursor) -> Option<(*mut K, *mut V, u64)> {
  [5.46676]

  [5.46909]
  + fn prev<'b>(p: Page<'b>, c: &mut Self::Cursor) -> Option<(&'b K, &'b V, u64)> {

  + if Self::move_prev(p, c) {

  + Self::current(p, c)

  + } else {

  + None

  + }

  + }

  + fn move_next(p: Page, c: &mut Self::Cursor) -> bool;

  + fn move_prev(p: Page, c: &mut Self::Cursor) -> bool;

  + unsafe fn unchecked_current<'a>(p: Page<'a>, c: &Self::Cursor) -> (&'a K, &'a V, u64);

  + fn current<'a>(p: Page<'a>, c: &Self::Cursor) -> Option<(&'a K, &'a V, u64)> {
• replacement in sanakirja-core/src/btree/mod.rs at line 54
  [5.46977]→[5.46977:47025](∅→∅)
  − Some(Self::unchecked_current(p, c))
  [5.46977]

  [5.47025]
  + unsafe {

  + Some(Self::unchecked_current(p, c))

  + }
• replacement in sanakirja-core/src/btree/mod.rs at line 59
  [5.47041]→[5.47041:47284](∅→∅)
  − unsafe fn unchecked_current_ptr(p: &Page, c: &Self::Cursor) -> *mut u8;

  − fn current_size(p: &Page, c: &Self::Cursor) -> usize;

  − fn left_child(p: &Page, c: &Self::Cursor) -> u64;

  − fn right_child(p: &Page, c: &Self::Cursor) -> u64;
  [5.47041]

  [5.47284]
  + unsafe fn unchecked_current_ptr(p: Page, c: &Self::Cursor) -> *const u8;

  + fn current_size(p: Page, c: &Self::Cursor) -> usize;

  + fn left_child(p: Page, c: &Self::Cursor) -> u64;

  + fn right_child(p: Page, c: &Self::Cursor) -> u64;
• replacement in sanakirja-core/src/btree/mod.rs at line 65
  [5.47324]→[5.47324:47345](∅→∅)
  − page: &Page,
  [5.47324]

  [5.47345]
  + page: Page,
• replacement in sanakirja-core/src/btree/mod.rs at line 69
  [5.47415]→[5.47415:47598](∅→∅)
  − ) -> Result<(&'a mut K, &'a mut V, u64), usize>;

  − fn split_at(p: &Page, c: &Self::Cursor) -> (Self::Cursor, Self::Cursor);

  − fn is_empty(p: &Page, c: &Self::Cursor) -> bool;
  [5.47415]

  [5.47598]
  + ) -> Result<(&'a K, &'a V, u64), usize>;

  + fn split_at(p: Page, c: &Self::Cursor) -> (Self::Cursor, Self::Cursor);

  + fn is_empty(p: Page, c: &Self::Cursor) -> bool;
• replacement in sanakirja-core/src/btree/mod.rs at line 82
  [5.47755]→[5.47755:47775](∅→∅)
  − page: &'a Page,
  [5.47755]

  [5.47775]
  + page: Page<'a>,
• replacement in sanakirja-core/src/btree/mod.rs at line 93
  [5.47966]→[5.47966:48011](∅→∅)
  − type Item = (&'a mut K, &'a mut V, u64);
  [5.47966]

  [5.48011]
  + type Item = (&'a K, &'a V, u64);
• replacement in sanakirja-core/src/btree/mod.rs at line 102
  [5.48225]→[5.48225:48282](∅→∅)
  − fn init(page: MutPage);

  − fn clean(page: MutPage);
  [5.48225]

  [5.48282]
  + fn init(page: &mut MutPage);

  + fn clean(page: &mut MutPage);
• replacement in sanakirja-core/src/btree/mod.rs at line 106
  [5.48319]→[5.48319:48339](∅→∅)
  − page: Page,
  [5.48319]

  [5.48339]
  + page: CowPage,
• replacement in sanakirja-core/src/btree/mod.rs at line 117
  [5.48548]→[5.48548:48568](∅→∅)
  − page: Page,
  [5.48548]

  [5.48568]
  + page: CowPage,
• replacement in sanakirja-core/src/btree/mod.rs at line 123
  [5.48665]→[5.48665:48757](∅→∅)
  − fn del(txn: &mut T, page: Page, c: &Self::Cursor, l: u64) -> Result<MutPage, T::Error>;
  [5.48665]

  [5.48757]
  + fn del(txn: &mut T, page: CowPage, c: &Self::Cursor, l: u64) -> Result<MutPage, T::Error>;
• replacement in sanakirja-core/src/btree/mod.rs at line 127
  [5.48799]→[5.48799:48819](∅→∅)
  − page: Page,
  [5.48799]

  [5.48819]
  + page: CowPage,
• replacement in sanakirja-core/src/btree/mod.rs at line 141
  [5.49208]→[5.49208:49239](∅→∅)
  − fn merge_or_rebalance<'a>(
  [5.49208]

  [5.49239]
  + fn merge_or_rebalance<'a, 'b>(
• replacement in sanakirja-core/src/btree/mod.rs at line 143
  [5.49260]→[5.49260:49299](∅→∅)
  − m: &mut Concat<T, K, V, Self>,
  [5.49260]

  [5.49299]
  + m: &'b mut Concat<'a, T, K, V, Self>,
• replacement in sanakirja-core/src/btree/mod.rs at line 148
  [5.49384]→[5.49384:49429](∅→∅)
  − m: &mut ModifiedPage<T, K, V, Self>,
  [5.49384]

  [5.49429]
  + m: &mut ModifiedPage<'a, T, K, V, Self>,
• replacement in sanakirja-core/src/btree/mod.rs at line 150
  [5.49472]→[5.49472:49773](∅→∅)
  − unsafe {

  − if let Some((k, v, r)) = m.ins {

  − if m.skip_first {

  − Self::replace(txn, m.page, m.mutable, &m.c1, &*k, &*v, m.l, r)

  − } else {

  − Self::put(txn, m.page, m.mutable, &m.c1, &*k, &*v, m.l, r)

  − }
  [5.49472]

  [5.49773]
  + if let Some((k, v, r)) = m.ins {

  + if m.skip_first {

  + Self::replace(txn, m.page, m.mutable, &m.c1, &*k, &*v, m.l, r)
• replacement in sanakirja-core/src/btree/mod.rs at line 154
  [5.49794]→[5.49794:50115](∅→∅)
  − let page = Self::del(txn, m.page, &m.c1, m.l)?;

  − Ok(Put::Ok(Ok {

  − page,

  − freed: if page.0.offset != m.page.offset {

  − m.page.offset

  − } else {

  − 0

  − },

  − }))
  [5.49794]

  [5.50115]
  + Self::put(txn, m.page, m.mutable, &m.c1, &*k, &*v, m.l, r)
• edit in sanakirja-core/src/btree/mod.rs at line 156
  [5.50129]

  [5.50129]
  + } else {

  + let page = Self::del(txn, m.page, &m.c1, m.l)?;

  + Ok(Put::Ok(Ok {

  + freed: if page.0.offset != m.page.offset {

  + m.page.offset

  + } else {

  + 0

  + },

  + page,

  + }))
• replacement in sanakirja-core/src/btree/mod.rs at line 179
  [5.50398]→[5.50398:50436](∅→∅)
  − k: *mut K,

  − v: *mut V,
  [5.50398]

  [5.50436]
  + k: &'a K,

  + v: &'a V,
• edit in sanakirja-core/src/btree/mod.rs at line 190
  [5.50582]

  [5.50582]
  + 'a,
• replacement in sanakirja-core/src/btree/mod.rs at line 196
  [5.50680]→[5.50680:50700](∅→∅)
  − pub page: Page,
  [5.50680]

  [5.50700]
  + pub page: CowPage,
• replacement in sanakirja-core/src/btree/mod.rs at line 204
  [5.50974]→[5.50974:51022](∅→∅)
  − pub ins: Option<(*const K, *const V, u64)>,
  [5.50974]

  [5.51022]
  + pub ins: Option<(&'a K, &'a V, u64)>,
• replacement in sanakirja-core/src/btree/mod.rs at line 211
  [5.51195]→[5.51195:51307](∅→∅)
  − impl<T: LoadPage, K: Representable<T>, V: Representable<T>, P: BTreePage<T, K, V>>

  − ModifiedPage<T, K, V, P>
  [5.51195]

  [5.51307]
  + impl<'a, T: LoadPage, K: Representable<T>, V: Representable<T>, P: BTreePage<T, K, V>>

  + ModifiedPage<'a, T, K, V, P>
• replacement in sanakirja-core/src/btree/mod.rs at line 217
  [5.51424]→[5.51424:51471](∅→∅)
  − P::move_next(&self.page, &mut c1);
  [5.51424]

  [5.51471]
  + P::move_next(self.page.as_page(), &mut c1);
• replacement in sanakirja-core/src/btree/mod.rs at line 219
  [5.51481]→[5.51481:51582](∅→∅)
  − if P::is_empty(&self.page, &self.c0) && self.ins.is_none() && P::is_empty(&self.page, &c1) {
  [5.51481]

  [5.51582]
  + if P::is_empty(self.page.as_page(), &self.c0) && self.ins.is_none() && P::is_empty(self.page.as_page(), &c1) {
• replacement in sanakirja-core/src/btree/mod.rs at line 230
  [5.51779]→[5.51779:51883](∅→∅)
  − pub mid: (*mut K, *mut V),

  − pub modified: &'a mut ModifiedPage<T, K, V, P>,

  − pub other: Page,
  [5.51779]

  [5.51883]
  + pub mid: (&'a K, &'a V),

  + pub modified: ModifiedPage<'a, T, K, V, P>,

  + pub other: CowPage,
• replacement in sanakirja-core/src/btree/mod.rs at line 240
  [5.52110]→[5.52110:52128](∅→∅)
  − pub db: Page,
  [5.52110]

  [5.52128]
  + pub db: CowPage,
• replacement in sanakirja-core/src/btree/mod.rs at line 252
  [5.52364]→[5.52364:52417](∅→∅)
  − let page = txn.alloc_page()?;

  − P::init(page);
  [5.52364]

  [5.52417]
  + let mut page = txn.alloc_page()?;

  + P::init(&mut page);
• edit in sanakirja-core/src/btree/del.rs at line 14
  [5.53074]

  [5.53074]
  + use log::*;
• replacement in sanakirja-core/src/btree/del.rs at line 20
  [5.53268]→[5.53268:53347](∅→∅)
  − T: AllocPage + LoadPage,

  − K: Representable<T>,

  − V: Representable<T>,
  [5.53268]

  [5.53347]
  + T: AllocPage + LoadPage + core::fmt::Debug,

  + K: Representable<T> + core::fmt::Debug,

  + V: Representable<T> + core::fmt::Debug,
• replacement in sanakirja-core/src/btree/del.rs at line 39
  [5.53725]→[5.53725:53804](∅→∅)
  − T: AllocPage + LoadPage,

  − K: Representable<T>,

  − V: Representable<T>,
  [5.53725]

  [5.53804]
  + T: AllocPage + LoadPage + core::fmt::Debug,

  + K: Representable<T> + core::fmt::Debug,

  + V: Representable<T> + core::fmt::Debug,
• replacement in sanakirja-core/src/btree/del.rs at line 59
  [5.54407]→[5.54407:54484](∅→∅)
  − let (c0, c1) = P::split_at(&curs0.page, curs0.cursor.as_ref().unwrap());
  [5.54407]

  [5.54484]
  + let (c0, c1) = P::split_at(curs0.page.as_page(), curs0.cursor.as_ref().unwrap());
• replacement in sanakirja-core/src/btree/del.rs at line 75
  [5.54905]→[5.54905:54949](∅→∅)
  − P::move_next(&curs0.page, &mut c1);
  [5.54905]

  [5.54949]
  + P::move_next(curs0.page.as_page(), &mut c1);
• replacement in sanakirja-core/src/btree/del.rs at line 77
  [5.54985]→[5.54985:55069](∅→∅)
  − P::next(&curs0.page, &mut c0).or_else(|| P::next(&curs0.page, &mut c1))
  [5.54985]

  [5.55069]
  + P::next(curs0.page.as_page(), &mut c0).or_else(|| P::next(curs0.page.as_page(), &mut c1))
• replacement in sanakirja-core/src/btree/del.rs at line 87
  [5.55342]→[5.55342:55410](∅→∅)
  − let (k, v, _) = P::unchecked_current(&curs0.page, &c0);
  [5.55342]

  [5.55410]
  + let (k, v, _) = P::unchecked_current(curs0.page.as_page(), &c0);
• edit in sanakirja-core/src/btree/del.rs at line 98
  [5.55678]

  [5.55678]
  + debug!("cursor.pointer = {:?}", cursor.pointer);
• replacement in sanakirja-core/src/btree/del.rs at line 101
  [5.55759]→[5.55759:55800](∅→∅)
  − let ref curs = cursor.current();
  [5.55759]

  [5.55800]
  + let mut concat = {

  + let p = cursor.pointer;

  + let curs = cursor.current_mut();

  + concat(txn, curs, if p == p0 { Some(&curs0) } else { None }, last_op)?

  + };

  + let curs = cursor.current();

  + debug!("candidate: {:?}", concat);
• replacement in sanakirja-core/src/btree/del.rs at line 109
  [5.55847]→[5.55847:55972](∅→∅)
  − let mut concat = concat(txn, &cursor, &curs0, p0, &mut last_op)?;

  − let (c0, c1) = P::split_at(&curs.page, c);
  [5.55847]

  [5.55972]
  + let (c0, c1) = P::split_at(curs.page.as_page(), c);
• edit in sanakirja-core/src/btree/del.rs at line 135
  [5.56877]→[5.56877:57005](∅→∅)
  − if cursor.pointer < cursor.first_rc_level {

  − free[cursor.pointer] = freed;

  − }
• edit in sanakirja-core/src/btree/del.rs at line 205
  [5.59597]

  [5.59597]
  +
• replacement in sanakirja-core/src/btree/del.rs at line 223
  [5.60108]→[5.60108:60185](∅→∅)
  − let page = txn.alloc_page()?;

  − P::init(page);
  [5.60108]

  [5.60185]
  + let mut page = txn.alloc_page()?;

  + P::init(&mut page);
• replacement in sanakirja-core/src/btree/del.rs at line 229
  [5.60288]→[5.60288:60335](∅→∅)
  − &P::first_cursor(&page.0),
  [5.60288]

  [5.60335]
  + &P::first_cursor(page.0.as_page()),
• replacement in sanakirja-core/src/btree/del.rs at line 269
  [5.61365]→[5.61365:61446](∅→∅)
  − let mut left_page = P::right_child(&cur.page, cur.cursor.as_ref().unwrap());
  [5.61365]

  [5.61446]
  + let mut left_page = P::right_child(cur.page.as_page(), cur.cursor.as_ref().unwrap());
• replacement in sanakirja-core/src/btree/del.rs at line 273
  [5.61547]→[5.61547:61639](∅→∅)
  − let curs = P::first_cursor(&page);

  − left_page = P::left_child(&page, &curs);
  [5.61547]

  [5.61639]
  + let curs = P::first_cursor(page.as_page());

  + left_page = P::left_child(page.as_page(), &curs);
• replacement in sanakirja-core/src/btree/del.rs at line 291
  [5.61957]→[5.61957:62088](∅→∅)
  − cursor: &Cursor<T, K, V, P>,

  − curs0: &PageCursor<T, K, V, P>,

  − p0: usize,

  − last_op: &'a mut ModifiedPage<T, K, V, P>,
  [5.61957]

  [5.62088]
  + curs: &mut PageCursor<T, K, V, P>,

  + curs0: Option<&PageCursor<T, K, V, P>>,

  + last_op: ModifiedPage<'a, T, K, V, P>,
• replacement in sanakirja-core/src/btree/del.rs at line 295
  [5.62136]→[5.62136:62312](∅→∅)
  − let ref curs = cursor.current();

  − let c = curs.cursor.as_ref().unwrap();

  − if cursor.pointer == p0 {

  − let other = txn.load_page(P::left_child(&curs.page, c))?;
  [5.62136]

  [5.62312]
  + let c = curs.cursor.as_mut().unwrap();

  + if let Some(curs0) = curs0 {

  + let other = txn.load_page(P::left_child(curs.page.as_page(), c))?;
• replacement in sanakirja-core/src/btree/del.rs at line 299
  [5.62336]→[5.62336:62426](∅→∅)
  − unsafe { P::unchecked_current(&curs0.page, curs0.cursor.as_ref().unwrap()) };
  [5.62336]

  [5.62426]
  + unsafe { P::unchecked_current(curs0.page.as_page(), curs0.cursor.as_ref().unwrap()) };
• replacement in sanakirja-core/src/btree/del.rs at line 302
  [5.62477]→[5.62477:62502](∅→∅)
  − mid: (k, v),
  [5.62477]

  [5.62502]
  + mid: unsafe { (core::mem::transmute(k), core::mem::transmute(v)) },
• replacement in sanakirja-core/src/btree/del.rs at line 307
  [5.62577]→[5.62577:62649](∅→∅)
  − let (k, v, r) = unsafe { P::unchecked_current(&curs.page, c) };
  [5.62577]

  [5.62649]
  + let mut mod_is_left = true;

  + let (k, v, r) = if let Some(x) = P::current(curs.page.as_page(), c) {

  + x

  + } else {

  + mod_is_left = false;

  + let (k, v, _) = P::prev(curs.page.as_page(), c).unwrap();

  + let l = P::left_child(curs.page.as_page(), c);

  + debug!("prev: {:?}", l);

  + (k, v, l)

  + };
• replacement in sanakirja-core/src/btree/del.rs at line 320
  [5.62739]→[5.62739:62764](∅→∅)
  − mid: (k, v),
  [5.62739]

  [5.62764]
  + mid: unsafe { (core::mem::transmute(k), core::mem::transmute(v))},
• replacement in sanakirja-core/src/btree/del.rs at line 322
  [5.62783]→[5.62783:62814](∅→∅)
  − mod_is_left: true,
  [5.62783]

  [5.62814]
  + mod_is_left,
• replacement in sanakirja-core/src/btree/del.rs at line 338
  [5.63098]→[5.63098:63206](∅→∅)
  − let mut left = P::left_child(&m.page, &c0);

  − while let Some((k, v, r)) = P::next(&m.page, &mut c0) {
  [5.63098]

  [5.63206]
  + let mut left = P::left_child(m.page.as_page(), &c0);

  + while let Some((k, v, r)) = P::next(m.page.as_page(), &mut c0) {
• replacement in sanakirja-core/src/btree/del.rs at line 347
  [5.63379]→[5.63379:63419](∅→∅)
  − P::move_next(&m.page, &mut c1);
  [5.63379]

  [5.63419]
  + P::move_next(m.page.as_page(), &mut c1);
• replacement in sanakirja-core/src/btree/del.rs at line 351
  [5.63466]→[5.63466:63526](∅→∅)
  − while let Some((k, v, r)) = P::next(&m.page, &mut c1) {
  [5.63466]

  [5.63526]
  + while let Some((k, v, r)) = P::next(m.page.as_page(), &mut c1) {
• replacement in sanakirja-core/src/btree/cursor.rs at line 2
  [5.63697]→[5.63697:63726](∅→∅)
  − use crate::{LoadPage, Page};
  [5.63697]

  [5.63726]
  + use crate::{LoadPage, CowPage};
• replacement in sanakirja-core/src/btree/cursor.rs at line 10
  [5.63901]→[5.63901:63921](∅→∅)
  − pub page: Page,
  [5.63901]

  [5.63921]
  + pub page: CowPage,
• replacement in sanakirja-core/src/btree/cursor.rs at line 65
  [5.65654]→[5.65654:65741](∅→∅)
  − impl<'a, T: LoadPage, K: Representable<T>, V: Representable<T>, P: BTreePage<T, K, V>>
  [5.65654]

  [5.65741]
  + impl<T: LoadPage, K: Representable<T>, V: Representable<T>, P: BTreePage<T, K, V>>
• replacement in sanakirja-core/src/btree/cursor.rs at line 72
  [5.65883]→[5.65883:65899](∅→∅)
  − pub fn set(
  [5.65883]

  [5.65899]
  + pub fn current_mut(&mut self) -> &mut PageCursor<T, K, V, P> {

  + unsafe { &mut *self.stack[self.pointer].as_mut_ptr() }

  + }

  +

  + pub fn set<'a>(
• replacement in sanakirja-core/src/btree/cursor.rs at line 80
  [5.65975]→[5.65975:66035](∅→∅)
  − ) -> Result<Option<(&'a mut K, &'a mut V)>, T::Error> {
  [5.65975]

  [5.66035]
  + ) -> Result<Option<(&'a K, &'a V)>, T::Error> {
• edit in sanakirja-core/src/btree/cursor.rs at line 86
  [3.2548]

  [3.2548]
  + debug!("p: {:?}", self.pointer);
• replacement in sanakirja-core/src/btree/cursor.rs at line 93
  [5.66557]→[5.66557:66620](∅→∅)
  − current.cursor = Some(P::first_cursor(&page));
  [5.66557]

  [5.66620]
  + current.cursor = Some(P::first_cursor(page.as_page()));
• replacement in sanakirja-core/src/btree/cursor.rs at line 97
  [5.66731]→[5.66731:66814](∅→∅)
  − if let Ok((kk, vv, _)) = P::set_cursor(txn, &page, cursor, k, v) {
  [5.66731]

  [5.66814]
  + if let Ok((kk, vv, _)) = P::set_cursor(txn, page.as_page(), cursor, k, v) {
• replacement in sanakirja-core/src/btree/cursor.rs at line 105
  [5.67059]→[5.67059:67117](∅→∅)
  − let next_page = P::left_child(&page, cursor);
  [5.67059]

  [5.67163]
  + let next_page = P::left_child(page.as_page(), cursor);

  + debug!("next_page = {:?}", next_page);
• replacement in sanakirja-core/src/btree/cursor.rs at line 109
  [5.67229]→[3.2649:2907](∅→∅)
  − unsafe {

  − *self.stack.get_unchecked_mut(self.pointer) = MaybeUninit::new(PageCursor {

  − page: txn.load_page(next_page)?,

  − cursor: None,

  − });

  − }
  [5.67229]

  [5.67409]
  + debug!("p+ = {:?}", self.pointer);

  + self.stack[self.pointer] = MaybeUninit::new(PageCursor {

  + page: txn.load_page(next_page)?,

  + cursor: None,

  + });
• edit in sanakirja-core/src/btree/cursor.rs at line 115
  [5.67430]

  [5.67430]
  + debug!("last p = {:?}", self.pointer);
• edit in sanakirja-core/src/btree/cursor.rs at line 120
  [5.67513]

  [5.67513]
  + debug!("last_matching {:?}", last_matching_page);
• edit in sanakirja-core/src/btree/cursor.rs at line 124
  [5.67604]

  [5.67604]
  + debug!("pointer {:?}", self.pointer);
• replacement in sanakirja-core/src/btree/cursor.rs at line 129
  [5.67642]→[5.67642:67731](∅→∅)
  − pub fn set_last(&mut self, txn: &'a T) -> Result<Option<(&'a K, &'a V)>, T::Error> {
  [5.67642]

  [5.67731]
  + pub fn set_last<'a>(&mut self, txn: &'a T) -> Result<Option<(&'a K, &'a V)>, T::Error> {
• replacement in sanakirja-core/src/btree/cursor.rs at line 139
  [5.68177]→[5.68177:68247](∅→∅)
  − current.cursor = Some(P::last_cursor(&current.page));
  [5.68177]

  [5.68247]
  + current.cursor = Some(P::last_cursor(current.page.as_page()));
• replacement in sanakirja-core/src/btree/cursor.rs at line 142
  [5.68320]→[5.68320:68404](∅→∅)
  − let (k, v, r) = unsafe { P::unchecked_current(&current.page, cursor) };
  [5.68320]

  [5.68404]
  + let (k, v, r) = unsafe { P::unchecked_current(current.page.as_page(), cursor) };
• replacement in sanakirja-core/src/btree/cursor.rs at line 154
  [5.68740]→[5.68740:68799](∅→∅)
  − Ok(last_match.map(|(k, v)| unsafe { (&*k, &*v) }))
  [5.68740]

  [5.68799]
  + Ok(last_match.map(|(k, v)| unsafe { (core::mem::transmute(k), core::mem::transmute(v)) }))
• replacement in sanakirja-core/src/btree/cursor.rs at line 157
  [5.68806]→[5.68806:68836](∅→∅)
  − pub fn next<L: LoadPage>(
  [5.68806]

  [5.68836]
  + pub fn next<'a, L: LoadPage>(
• replacement in sanakirja-core/src/btree/cursor.rs at line 160
  [5.68879]→[5.68879:68933](∅→∅)
  − ) -> Result<Option<(&mut K, &mut V)>, L::Error> {
  [5.68879]

  [5.68933]
  + ) -> Result<Option<(&K, &V)>, L::Error> {
• replacement in sanakirja-core/src/btree/cursor.rs at line 170
  [5.69343]→[5.69343:69416](∅→∅)
  − if let Some((k, v, r)) = P::next(&current.page, c) {
  [5.69343]

  [5.69416]
  + if let Some((k, v, r)) = P::next(current.page.as_page(), c) {
• replacement in sanakirja-core/src/btree/cursor.rs at line 178
  [5.69743]→[5.69743:69804](∅→∅)
  − return Ok(Some((&mut *k, &mut *v)));
  [5.69743]

  [5.69804]
  + return Ok(Some((& *k, & *v)));
• replacement in sanakirja-core/src/btree/cursor.rs at line 185
  [5.70012]→[5.70012:70087](∅→∅)
  − current.cursor = Some(P::first_cursor(&current.page));
  [5.70012]

  [5.70087]
  + current.cursor = Some(P::first_cursor(current.page.as_page()));
• replacement in sanakirja-core/src/btree/cursor.rs at line 188
  [5.70218]→[5.70218:70287](∅→∅)
  − let left = P::left_child(&current.page, cursor);
  [5.70218]

  [5.70287]
  + let left = P::left_child(current.page.as_page(), cursor);
• edit in sanakirja/src/main.rs at line 1
  [5.77822]→[5.77823:77839](∅→∅)
  − use lmdb_rs::*;
• edit in sanakirja/src/main.rs at line 4
  [5.77912]

  [5.77912]
  + use sanakirja_core::btree;

  + use sanakirja_core::*;
• edit in sanakirja/src/main.rs at line 8
  [5.77940]

  [5.77940]
  + mod debug;
• replacement in sanakirja/src/main.rs at line 10
  [5.77941]→[5.77941:77995](∅→∅)
  − type B = sanakirja_core::btree::page::Page<u64, u64>;
  [5.77941]

  [5.77995]
  + type B<T> = btree::page::Page<u64, A<T>>;
• edit in sanakirja/src/main.rs at line 18
  [5.78088]

  [5.78088]
  + #[derive(Eq, PartialEq, PartialOrd, Ord)]

  + struct A<T>([u64; 100], std::marker::PhantomData<T>);

  +

  + impl<T> std::fmt::Debug for A<T> {

  + fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {

  + write!(fmt, "A(…)")?;

  + Ok(())

  + }

  + }

  +

  + impl<T> Representable<T> for A<T> {

  + type PageOffsets = core::iter::Empty<u64>;

  + fn page_offsets(&self) -> Self::PageOffsets {

  + core::iter::empty()

  + }

  + const ALIGN: usize = core::mem::align_of::<Self>();

  + const SIZE: Option<usize> = Some(core::mem::size_of::<Self>());

  + type Ord = [u64; 100];

  + fn ord(&self, _: &T) -> &Self::Ord {

  + &self.0

  + }

  + fn size(&self) -> usize {

  + core::mem::size_of::<Self>()

  + }

  + }

  +

  + type T<'a> = MutTxn<&'a Env<Exclusive>, ()>;

  +
• edit in sanakirja/src/main.rs at line 48
  [5.78117]

  [5.78117]
  + #[test]
• edit in sanakirja/src/main.rs at line 50
  [5.78137]

  [5.78137]
  + env_logger::try_init().unwrap_or(());
• replacement in sanakirja/src/main.rs at line 53
  [5.78247]→[5.78247:78372](∅→∅)
  − let mut db = create_db::<MutTxn<&Env<Exclusive>, ()>, u64, u64, B>(&mut txn).unwrap();

  − let n = 1_000_000u64;
  [5.78247]

  [5.78372]
  + let mut db = create_db::<MutTxn<&Env<Exclusive>, ()>, u64, A<T>, B<T>>(&mut txn).unwrap();

  + let n = 501;
• replacement in sanakirja/src/main.rs at line 58
  [5.78479]→[4.209:292](∅→∅)
  − put(&mut txn, &mut db, &((i * i) % 1_000_000), &(i * i * i)).unwrap();
  [5.78479]

  [5.78548]
  + let a = A([i * i * i; 100], std::marker::PhantomData);

  + put(&mut txn, &mut db, &((i * i) % 1_000_000), &a).unwrap();
• replacement in sanakirja/src/main.rs at line 63
  [5.78605]→[4.293:445](∅→∅)
  − for i in 0..n {

  − debug!("put {:?}", i);

  − put(&mut txn, &mut db, &((i * i) % 1_000_000), &(i * i * i)).unwrap();

  − }
  [5.78605]

  [5.78616]
  + let i = 500;

  + debug!("deleting {:?}", (i*i)%1_000_000);

  + del(&mut txn, &mut db, &((i * i) % 1_000_000), None).unwrap();

  + debug::debug(&txn, &db, "debug", true);

  + /*
• replacement in sanakirja/src/main.rs at line 71
  [5.78747]→[5.78747:78820](∅→∅)
  − debug!("put {:?}", i);

  − btree.insert(i*i, i*i*i);
  [5.78747]

  [5.78820]
  + btree.insert(i * i, i * i * i);
• edit in sanakirja/src/main.rs at line 74
  [5.78876]

  [3.2908]
  + */

  +
• replacement in sanakirja/src/environment/muttxn.rs at line 3
  [5.80193]→[5.80193:80237](∅→∅)
  − use sanakirja_core::{btree, MutPage, Page};
  [5.80193]

  [5.80237]
  + use sanakirja_core::{btree, CowPage, MutPage};
• edit in sanakirja/src/environment/muttxn.rs at line 6
  [5.80263]

  [5.80263]
  + impl<E:Borrow<Env<Exclusive>>, T> std::fmt::Debug for MutTxn<E, T> {

  + fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {

  + write!(fmt, "MutTxn {{ }}")

  + }

  + }

  +
• replacement in sanakirja/src/environment/muttxn.rs at line 17
  [5.80384]→[5.80384:80400](∅→∅)
  − free: Page,
  [5.80384]

  [5.80400]
  + free: CowPage,
• replacement in sanakirja/src/environment/muttxn.rs at line 50
  [5.81368]→[5.81368:81411](∅→∅)
  − fn commit(self) -> Result<(), Error> {
  [5.81368]

  [5.81411]
  + fn commit(mut self) -> Result<(), Error> {
• replacement in sanakirja/src/environment/muttxn.rs at line 55
  [5.81545]→[5.81545:81609](∅→∅)
  − .extend(self.occupied_owned_pages.iter().cloned());
  [5.81545]

  [5.81609]
  + .extend(self.occupied_owned_pages.drain(..));
• replacement in sanakirja/src/environment/muttxn.rs at line 87
  [5.82918]→[5.82918:82952](∅→∅)
  − let free = Page {
  [5.82918]

  [5.82952]
  + let free = CowPage {
• replacement in sanakirja/src/environment/muttxn.rs at line 95
  [5.83210]→[5.83210:83245](∅→∅)
  − db: Page {
  [5.83210]

  [5.83245]
  + db: CowPage {
• replacement in sanakirja/src/environment/muttxn.rs at line 129
  [5.84354]→[5.84354:84381](∅→∅)
  − Page {
  [5.84354]

  [5.84381]
  + CowPage {
• replacement in sanakirja/src/environment/muttxn.rs at line 207
  [5.87264]→[5.87264:87526](∅→∅)
  − if let Some(page) = self.free_owned_pages.pop() {

  − let page = MutPage(Page {

  − data: unsafe { self.env.borrow().find_offset(page) },

  − offset: page,

  − });

  − self.occupied_owned_pages.push(page);
  [5.87264]

  [5.87526]
  + if let Some(offset) = self.free_owned_pages.pop() {

  + let data = unsafe { self.env.borrow().find_offset(offset) };

  + let page = MutPage(CowPage { data, offset });

  + self.occupied_owned_pages

  + .push(MutPage(CowPage { data, offset }));
• replacement in sanakirja/src/environment/muttxn.rs at line 215
  [5.87620]→[5.87620:87901](∅→∅)
  − if let Some(page) = self.free_pages_pop()? {

  − let page = MutPage(Page {

  − data: unsafe { self.env.borrow().find_offset(page) },

  − offset: page,

  − });

  − self.occupied_owned_pages.push(page);
  [5.87620]

  [5.87901]
  + if let Some(offset) = self.free_pages_pop()? {

  + let data = unsafe { self.env.borrow().find_offset(offset) };

  + let page = MutPage(CowPage { data, offset });

  + self.occupied_owned_pages

  + .push(MutPage(CowPage { offset, data }));
• replacement in sanakirja/src/environment/muttxn.rs at line 224
  [5.88072]→[5.88072:88112](∅→∅)
  − let last = self.length;
  [5.88072]

  [5.88112]
  + let offset = self.length;
• replacement in sanakirja/src/environment/muttxn.rs at line 226
  [5.88161]→[5.88161:88311](∅→∅)
  − let page = MutPage(Page {

  − data: unsafe { self.env.borrow().find_offset(last) },

  − offset: last,
  [5.88161]

  [5.88311]
  + let data = unsafe { self.env.borrow().find_offset(offset) };

  + let page = MutPage(CowPage {

  + data,

  + offset,
• replacement in sanakirja/src/environment/muttxn.rs at line 231
  [5.88331]→[5.88331:88385](∅→∅)
  − self.occupied_owned_pages.push(page);
  [5.88331]

  [5.88385]
  + self.occupied_owned_pages.push(MutPage(CowPage { data, offset }));
• replacement in sanakirja/src/environment/muttxn.rs at line 241
  [5.88658]→[5.88658:89095](∅→∅)
  − if let Some((rc, ())) = curs.next(self)? {

  − let off_ = *rc & !0xfff;

  − if off_ == off {

  − let r = *rc & 0xfff;

  − if r > 2 {

  − *rc = off_ | (r - 1);

  − } else {

  − btree::del(self, &mut rc_, rc, None)?;

  − }

  − self.rc = Some(rc_);

  − return Ok(());
  [5.88658]

  [5.89095]
  + let rc = if let Some((rc, ())) = curs.next(self)? {

  + if *rc & !0xfff == off {

  + *rc

  + } else {

  + 1
• edit in sanakirja/src/environment/muttxn.rs at line 247
  [5.89113]

  [5.89113]
  + } else {

  + 1

  + };

  + if rc & 0xfff >= 2 {

  + btree::del(self, &mut rc_, &rc, None)?;

  + if rc > 2 {

  + btree::put(self, &mut rc_, &(rc - 1), &())?;

  + }

  + return Ok(())
• edit in sanakirja/src/environment/muttxn.rs at line 263
  [5.89253]→[5.89253:89281](∅→∅)
  − let mut rc_del = 0;
• replacement in sanakirja/src/environment/muttxn.rs at line 265
  [5.89390]→[5.89390:89828](∅→∅)
  − if let Some((rc, _)) = curs.set(self, Some((&off, None)))? {

  − let off_ = *rc & !0xfff;

  − if off_ == off {

  − let r = *rc & 0xfff;

  − if r > 2 {

  − *rc = off_ | (r - 1);

  − self.rc = Some(rc_);

  − return Ok(());

  − } else {

  − rc_del = *rc;

  − }
  [5.89390]

  [5.89828]
  + curs.set(self, Some((&off, None)))?;

  + let rc = if let Some((rc, ())) = curs.next(self)? {

  + if *rc & !0xfff == off {

  + *rc

  + } else {

  + 1

  + }

  + } else {

  + 1

  + };

  + if rc & 0xfff >= 2 {

  + btree::del(self, &mut rc_, &rc, None)?;

  + if rc > 2 {

  + btree::put(self, &mut rc_, &(rc - 1), &())?;
• replacement in sanakirja/src/environment/muttxn.rs at line 280
  [5.89846]→[5.89846:89949](∅→∅)
  − }

  − if rc_del != 0 {

  − btree::del(self, &mut rc_, &rc_del, None)?;
  [5.89846]

  [5.89949]
  + return Ok(())
• edit in sanakirja/src/environment/muttxn.rs at line 282
  [5.89963]→[5.89963:89996](∅→∅)
  − self.rc = Some(rc_);
• replacement in sanakirja/src/environment/muttxn.rs at line 290
  [5.90231]→[5.90231:90461](∅→∅)
  − if let Some((rc, _)) = curs.set(self, Some((&off, None)))? {

  − let off_ = *rc & !0xfff;

  − if off_ == off {

  − let r = *rc & 0xfff;

  − *rc = off_ | (r + 1);
  [5.90231]

  [5.90461]
  + let rc = if let Some((rc, _)) = curs.set(self, Some((&off, None)))? {

  + if *rc & !0xfff == off {

  + *rc & 0xfff
• replacement in sanakirja/src/environment/muttxn.rs at line 294
  [5.90486]→[5.90486:90552](∅→∅)
  − btree::put(self, &mut rc_, &(off | 2), &())?;
  [5.90486]

  [5.90552]
  + 1
• replacement in sanakirja/src/environment/muttxn.rs at line 297
  [5.90591]→[5.90591:90653](∅→∅)
  − btree::put(self, &mut rc_, &(off | 2), &())?;
  [5.90591]

  [5.90653]
  + 1

  + };

  + if rc > 1 {

  + btree::del_at_cursor(self, &mut rc_, &mut curs)?;
• edit in sanakirja/src/environment/muttxn.rs at line 302
  [5.90667]

  [5.90667]
  + assert!(rc + 1 <= 0xfff);

  + btree::put(self, &mut rc_, &(off | (rc + 1)), &())?;
• replacement in sanakirja/src/environment/muttxn.rs at line 312
  [5.90843]→[5.90843:90908](∅→∅)
  − fn load_page(&self, off: u64) -> Result<Page, Self::Error> {
  [5.90843]

  [5.90908]
  + fn load_page(&self, off: u64) -> Result<CowPage, Self::Error> {
• replacement in sanakirja/src/environment/muttxn.rs at line 315
  [5.90984]→[5.90984:91027](∅→∅)
  − Ok(Page { data, offset: off })
  [5.90984]

  [5.91027]
  + Ok(CowPage { data, offset: off })
• replacement in sanakirja/src/environment/mod.rs at line 7
  [5.91734]→[5.91734:91760](∅→∅)
  − use sanakirja_core::Page;
  [5.91734]

  [5.91760]
  + use sanakirja_core::CowPage;
• replacement in sanakirja/src/environment/mod.rs at line 454
  [5.106393]→[5.106393:106458](∅→∅)
  − fn load_page(&self, off: u64) -> Result<Page, Self::Error> {
  [5.106393]

  [5.106458]
  + fn load_page(&self, off: u64) -> Result<CowPage, Self::Error> {
• replacement in sanakirja/src/environment/mod.rs at line 458
  [5.106564]→[5.106564:106607](∅→∅)
  − Ok(Page { data, offset: off })
  [5.106564]

  [5.106607]
  + Ok(CowPage { data, offset: off })