let mut last_freed = 0;

                incr_descendants::<T, K, V, P>(txn, cursor, free, freed, &mut last_freed)?;

                incr_descendants::<T, K, V, P>(txn, cursor, free, freed)?;

                    )?

                    )?;

                incr_descendants::<T, K, V, P>(txn, cursor, free, freed, &mut last_freed)?;

                incr_descendants::<T, K, V, P>(txn, cursor, free, freed)?;

    freed: u64,
    last_freed: &mut u64,

    mut freed: u64,

    // The freed page is on the page below.

        // Else, the "freed" page is shared with another tree, and
        // hence we just need to decrement its RC.
        if cursor.len() == cursor.first_rc_len() {
            debug_assert_ne!(freed, 0);
            free[cursor.len()] = freed;
        }

        let cur = cursor.current();

        let cur = cursor.cur();

        if left != 0 && left != *last_freed {
            txn.incr_rc(left)?;

        if left != 0 {
            if left != (freed & !1) {
                txn.incr_rc(left)?;
            } else if cursor.len() == cursor.first_rc_len() {
                freed = 0
            }

            if r != 0 && r != *last_freed {
                txn.incr_rc(r)?;

            if r != 0 {
                if r != (freed & !1) {
                    txn.incr_rc(r)?;
                } else if cursor.len() == cursor.first_rc_len() {
                    freed = 0
                }

        }
        // Else, the "freed" page is shared with another tree, and
        // hence we just need to decrement its RC.
        if freed > 0 && cursor.len() == cursor.first_rc_len() {
            free[cursor.len()] = freed;

    // Finally, update the last freed page to be the page we just
    // freed (the `&!1` is here because `freed` might have its LSB set
    // to indicate that `freed` was allocated by the current
    // transaction, but that bit isn't set in references to page
    // `freed` on the parent page).
    *last_freed = freed & !1;

                unsafe { *(page.data.as_ptr().add((HDR + c.cur as usize * 8) - 8) as *const u64) };

                unsafe { *(page.data.as_ptr().offset(HDR as isize + c.cur * 8 - 8) as *const u64) };

            let off = unsafe { *(page.data.as_ptr().add(HDR + c.cur as usize * 8) as *const u64) };

            let off = unsafe { *(page.data.as_ptr().offset(HDR as isize + c.cur * 8) as *const u64) };

    fn set_left_child(new: &mut MutPage, n: isize, l: u64);

    // This is the exact same implementation as in the sized
    // module. I'm not convinced

    if l != 0 {
        // The while loop above didn't run, i.e. the insertion
        // happened at the end of the page. In this case, we haven't
        // had a chance to update the left page, so do it now.
        L::set_left_child(new, *n, l)
    }

    // This algorithm is probably a bit naive, especially for leaves,
    // where if the left page is mutable, we can copy the other page
    // onto it.
    // Indeed, we first allocate a page, then clone both pages onto
    // it, in a different order depending on whether the modified page
    // is the left or the right child.

    // Here, we first allocate a page, then clone both pages onto it,
    // in a different order depending on whether the modified page is
    // the left or the right child.
    //
    // Note that in the case that this merge happens immediately after
    // a put that reallocated the two sides of the merge in order to
    // split (not all splits do that), we could be slightly more
    // efficient, but with considerably more code.

        if let Put::Ok(Ok { freed, page }) = <Page<K, V>>::put(
            txn, page.0, true, false, &lc, m.mid.0, m.mid.1, None, 0, rl,
        )? {

        if let Put::Ok(Ok { freed, page }) =
            <Page<K, V>>::put(txn, page.0, true, false, &lc, m.mid.0, m.mid.1, None, 0, rl)?
        {

            txn, m.modified.page, m.modified.mutable, false, &lc, m.mid.0, m.mid.1, None, 0, rl,

            txn,
            m.modified.page,
            m.modified.mutable,
            false,
            &lc,
            m.mid.0,
            m.mid.1,
            None,
            0,
            rl,

            if m.modified.l > 0 {
                assert_eq!(m.modified.r, 0);
                unsafe {
                    let off = (page.0.data.add(HDR) as *mut u64).offset(m.modified.c1.cur - 1);
                    *off = (m.modified.l | (u64::from_le(*off) & 0xfff)).to_le();
                }
            } else if m.modified.r > 0 {
                unsafe {
                    let off = (page.0.data.add(HDR) as *mut u64).offset(m.modified.c1.cur);
                    *off = (m.modified.r | (u64::from_le(*off) & 0xfff)).to_le();
                }
            }

        incr_kv_rc: !m.other_is_mutable,

pub(crate) fn rebalance_right<'a, T: AllocPage, K: ?Sized, V: ?Sized, P: BTreeMutPage<K, V>>(

pub(crate) fn rebalance_right<
    'a,
    T: AllocPage,
    K: ?Sized,
    V: ?Sized,
    P: BTreeMutPage<K, V, Cursor = super::PageCursor>,
>(

    // First element of the right page.
    let rc = P::cursor_first(&m.modified.page);
    let rl = P::left_child(m.modified.page.as_page(), &rc);

        // First element of the right page (after potential
        // modification by `put` above).
        let rc = P::cursor_first(&new_right.0);
        let rl = P::left_child(new_right.0.as_page(), &rc);

        // mutable, since we just modified it (hence the
        // `assert_eq!(freed, 0)`.

        // mutable, since we just modified it. Moreover, if it is
        // compacted by the `put` below, we know that the `del` didn't
        // free anything, hence we can reuse the slot 0..
        // First element of the right page (after potential
        // modification by `del` above).
        let rc = P::cursor_first(&page.0);
        let rl = P::left_child(page.0.as_page(), &rc);

            txn,
            page.0,
            true,
            false,
            &rc,
            m.mid.0,
            m.mid.1,
            None,
            r0,
            rl,

            txn, page.0, true, false, &rc, m.mid.0, m.mid.1, None, r0, rl,

            debug_assert_eq!(freed, 0);

            if freed > 0 {
                freed_[0] = if is_dirty { freed | 1 } else { freed };
            }

        let rc = P::cursor_first(&m.modified.page);
        let rl = P::left_child(m.modified.page.as_page(), &rc);

            // Update the left and right offsets. We know that at
            // least one of them is 0, but it can be either one (or
            // both), depending on what happened on the page below.
            //
            // Since we inserted an entry at the beginning of the
            // page, we need to add 1 to the index given by
            // `m.modified.c1.cur`.
            if m.modified.l > 0 {
                assert_eq!(m.modified.r, 0);
                unsafe {
                    let off = (page.0.data.add(HDR) as *mut u64).offset(m.modified.c1.cur);
                    *off = (m.modified.l | (u64::from_le(*off) & 0xfff)).to_le();
                }
            } else if m.modified.r > 0 {
                unsafe {
                    let off = (page.0.data.add(HDR) as *mut u64).offset(m.modified.c1.cur + 1);
                    *off = (m.modified.r | (u64::from_le(*off) & 0xfff)).to_le();
                }
            }

        incr_kv_rc: !m.modified.mutable,

    }
    fn set_left_child(_new: &mut MutPage, _n: isize, l: u64) {
        debug_assert_eq!(l, 0);

    }
    fn set_left_child(new: &mut MutPage, n: isize, l: u64) {
        if l > 0 {
            Internal::set_right_child(new, n - 1, l);
        }

    assert!(off as usize + core::mem::size_of::<Tuple<K, V>>() <= PAGE_SIZE);

    if off as usize + core::mem::size_of::<Tuple<K, V>>() > PAGE_SIZE {
        panic!("off = {:?}, size = {:?}", off, core::mem::size_of::<Tuple<K, V>>());
    }

            let a = core::mem::size_of::<Tuple<K, V>>();

            let a = core::mem::align_of::<Tuple<K, V>>();

        // Looking at module `super::del`, the only way we can be in
        // this case

            if m.modified.l > 0 {
                assert_eq!(m.modified.r, 0);
                unsafe {
                    let off = (page.0.data.add(HDR) as *mut u64).offset(m.modified.c1.cur - 1);
                    *off = (m.modified.l | (u64::from_le(*off) & 0xfff)).to_le();
                }
            } else if m.modified.r > 0 {
                unsafe {
                    let off = (page.0.data.add(HDR) as *mut u64).offset(m.modified.c1.cur);
                    *off = (m.modified.r | (u64::from_le(*off) & 0xfff)).to_le();
                }
            }

        incr_kv_rc: !m.other_is_mutable,

            <Page<K, V> as BTreeMutPage<K, V>>::init(&mut left);

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

    }
    fn set_left_child(new: &mut MutPage, n: isize, l: u64) {
        if l > 0 {
            Internal::set_right_child(new, n - 1, l);
        }

    }
    fn set_left_child(_new: &mut MutPage, _n: isize, l: u64) {
        debug_assert_eq!(l, 0);

        // Do `k` and `v` come from a page shared with another tree?
        incr_kv_rc: bool,

    K: Storable + ?Sized + core::fmt::Debug,

    K: Storable + ?Sized + core::fmt::Debug + PartialEq,

    K: Storable + ?Sized + core::fmt::Debug,

    K: Storable + ?Sized + core::fmt::Debug + PartialEq,

            let cur = cursor.current();

            let cur = cursor.cur();

    let cur = cursor.current();

    let cur = cursor.cur();

        let incr_page = if !concat.other_is_mutable {
            Some(CowPage {
                offset: concat.other.offset,
                data: concat.other.data,
            })
        } else {
            None
        };
        let incr_mid = if cursor.len() >= cursor.first_rc_len() {
            Some(concat.mid)
        } else {
            None
        };

        last_op = handle_merge(txn, cursor, p0, &k0v0, mil, merge, &mut free)?;

        last_op = handle_merge(txn, cursor, p0, &k0v0, incr_page, incr_mid, mil, merge, &mut free)?;

    T: AllocPage + LoadPage + core::fmt::Debug,
    K: Storable + ?Sized + core::fmt::Debug,
    V: Storable + ?Sized + core::fmt::Debug,
    P: BTreeMutPage<K, V> + core::fmt::Debug + 'a,

    T: AllocPage + LoadPage,
    K: Storable + ?Sized,
    V: Storable + ?Sized,
    P: BTreeMutPage<K, V> + 'a,

    K: Storable + ?Sized,

    K: Storable + ?Sized + PartialEq,

    P: BTreeMutPage<K, V> + core::fmt::Debug,

    P: BTreeMutPage<K, V>,

    incr_other: Option<CowPage>,
    incr_mid: Option<(&K, &V)>,

    // For merges and rebalances, take care of the reference counts of
    // pages and key/values.
    match merge {
        Op::Merged {.. } | Op::Rebalanced { .. } => {
            // Increase the RC of the "other page's" descendants. In
            // the case of a rebalance, this has the effect of
            // increasing the RC of the new middle entry if that entry
            // comes from a shared page, which is what we want.
            if let Some(other) = incr_other {
                let mut curs = P::cursor_first(&other);
                let left = P::left_child(other.as_page(), &curs);
                txn.incr_rc(left)?;
                while let Some((k0, v0, r)) = P::next(txn, other.as_page(), &mut curs) {
                    for o in k0.page_references().chain(v0.page_references()) {
                        txn.incr_rc(o)?;
                    }
                    if r != 0 {
                        txn.incr_rc(r)?;
                    }
                }
            }
            // If the middle element comes from a shared page,
            // increment its references.
            if let Some((ref k, ref v)) = incr_mid {
                for o in k.page_references().chain(v.page_references()) {
                    txn.incr_rc(o)?;
                }
            }
        }
        _ => {}
    }

            incr_kv_rc,

            if incr_kv_rc {
                // Here, note that the rebalancing element cannot
                // possibly be the replacement element, so since it is
                // copied, we need to increment its RC (the
                // replacement entry has its RC incremented at
                // deletion).
                for o in k.page_references().chain(v.page_references()) {
                    txn.incr_rc(o)?;
                }
            }

        if m.r == 0 && r != 0 {

        // If `m.skip_first`, we have already skipped the entry above,
        // so this `r` has nothing to do with any update.
        //
        // Else, if we aren't skipping, but also aren't updating the
        // right child of the current entry, also increase the RC.
        if (m.skip_first || m.r == 0) && r != 0 {

impl<K: ?Sized + core::fmt::Debug, V: ?Sized, P: BTreePage<K, V>> Cursor<K, V, P> {

impl<K: ?Sized + Storable, V: ?Sized + Storable, P: BTreePage<K, V>> Cursor<K, V, P> {

    pub(super) fn current(&self) -> &PageCursor<K, V, P> {

    pub(super) fn cur(&self) -> &PageCursor<K, V, P> {

    ) -> Result<Option<(&'a K, &'a V)>, T::Error> {
        let mut last_match;

    ) -> Result<(), T::Error> {

        current.cursor = P::cursor_last(&current.page);

        current.cursor = P::cursor_after(&current.page);

            }
            let l = P::left_child(current.page.as_page(), &current.cursor);
            if l > 0 {
                let page = txn.load_page(l)?;
                self.push(PageCursor {
                    cursor: P::cursor_after(&page),
                    page,
                })
            } else {
                break;

            if let Some((k, v, r)) = P::current(txn, current.page.as_page(), &mut current.cursor) {
                last_match = Some((k, v));
                if r > 0 {
                    let page = txn.load_page(r)?;
                    self.push(PageCursor {
                        cursor: P::cursor_last(&page),
                        page,
                    })
                } else {
                    break;

        }
        Ok(())
    }
    /// Return the current position of the cursor.
    pub fn current<'a, T: LoadPage>(
        &mut self,
        txn: &'a T,
    ) -> Result<Option<(&'a K, &'a V)>, T::Error> {
        loop {
            let current = unsafe { &mut *self.stack[self.len - 1].as_mut_ptr() };
            if P::is_init(&current.cursor) {
                // The cursor hasn't been set.
                return Ok(None)
            } else if let Some((k, v, _)) = P::current(txn, current.page.as_page(), &current.cursor)
            {
                unsafe {
                    return Ok(Some((core::mem::transmute(k), core::mem::transmute(v))));

            } else if self.len > 1 {
                self.len -= 1

                // The page is empty, meaning there's no right or left child.
                debug_assert!(P::is_init(&current.cursor));
                // Assert we're looking at the root.
                debug_assert_eq!(self.len, 1);
                // And the root has no child.
                debug_assert_eq!(P::right_child(current.page.as_page(), &current.cursor), 0);

                // We're past the last element at the root.

        Ok(last_match.map(|(k, v)| unsafe { (core::mem::transmute(k), core::mem::transmute(v)) }))

    /// Move the cursor to the previous entry, and return that
    /// entry.

    /// Move the cursor to the previous entry, and return the current
    /// entry. If the cursor is initially after all the entries, this
    /// moves it back by two steps.

                    // We are at a leaf.

version = "1.0.2"

version = "1.1.0"

crc32fast = { version = "1.2", optional = true, default-features = false }

crc32fast = { version = "1.2", optional = true, default-features = false }

}
#[derive(Eq, PartialEq, PartialOrd, Ord, Hash, Clone, Copy)]
struct U([u64; 3]);
direct_repr!(U);
#[derive(Eq, PartialEq, PartialOrd, Ord, Hash, Clone, Copy)]
struct V([u64; 5]);
direct_repr!(V);
impl std::fmt::Debug for U {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(fmt, "U({})", self.0[0])
    }
}
impl std::fmt::Debug for V {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(fmt, "V")
    }
}
#[test]
pub fn random_scenario_sized_fork() {
    let path = "/home/pe/bla/db";
    let l0 = 1 << 20;
    std::fs::remove_file(path).unwrap_or(());
    let env = Env::new(&path, l0, 1).unwrap();
    let mut txn = Env::mut_txn_begin(&env).unwrap();
    let mut db = create_db::<MutTxn<&Env, ()>, U, V>(&mut txn).unwrap();
    use rand::{Rng, SeedableRng};
    let mut rng = rand::rngs::SmallRng::from_seed(*b"rc',.snjcg'sthomw,.vbw,.p84fcxjw");
    let mut ve: Vec<(U, V)> = Vec::with_capacity(100_000);
    use std::collections::HashMap;
    let mut h: HashMap<U, V> = HashMap::with_capacity(100_000);
    let mut refs = BTreeMap::new();
    let mut dbs = Vec::new();
    for i in 0.. {
        let do_debug = i > 5618; // i % 1_000_000 == 0;
        if do_debug {
            env_logger::try_init().unwrap_or(());
            info!("========== i = {:?} {:?}", i, db.db);
        }
        dbs.push(fork_db(&mut txn, &db).unwrap());
        if rng.gen_range(0..4) == 3 {
            if let Some((k, v)) = ve.pop() {
                if do_debug {
                    debug!("del {:?} {:?}", k.0[0], v.0[0]);
                }
                assert!(del(&mut txn, &mut db, &k, Some(&v)).unwrap())
            }
        } else {
            let k = U([rng.gen(), rng.gen(), rng.gen()]);
            let v = V([rng.gen(), rng.gen(), rng.gen(), rng.gen(), rng.gen()]);
            if do_debug {
                debug!("put {:?} {:?}", k.0[0], v.0[0]);
            }
            put(&mut txn, &mut db, &k, &v).unwrap();
            ve.push((k, v));
            h.insert(k, v);
        }
        if do_debug {
            debug(&txn, &[&db], format!("debug_{}", i), true);
            for (i, (k, v)) in ve.iter().enumerate() {
                if get(&txn, &db, k, None).unwrap() != Some((k, v)) {
                    panic!("test {:?} {:?} {:?}", i, k.0[0], v.0[0]);
                }
            }
            for x in iter(&txn, &db, None).unwrap() {
                let (k, v) = x.unwrap();
                if h.get(k) != Some(v) {
                    panic!("test {:?}", k);
                }
            }
            refs.clear();
            add_refs(&txn, &db, &mut refs).unwrap();
            for db in dbs.iter() {
                add_refs(&txn, db, &mut refs).unwrap();
            }
            add_free_refs_mut(&txn, &mut refs).unwrap();
            check_free_mut(&mut txn, &refs);
            if let Some(ref rc) = txn.rc {
                let mut last = 0;
                for r in iter(&txn, rc, None).unwrap() {
                    let (r, _) = r.unwrap();
                    if last > 0 && last == (r & !0xfff) {
                        panic!("r = {:?} last = {:?}", r, last);
                    }
                    last = r & !0xfff;
                }
            }
            let mut n = Vec::new();
            for (p, r) in refs.iter() {
                if *r >= 2 {
                    let rc = txn.rc(*p).unwrap();
                    if rc != *r as u64 {
                        n.push((p, *r, rc))
                    }
                } else {
                    assert_eq!(txn.rc(*p).unwrap(), 0);
                }
            }
            if !n.is_empty() {
                panic!("n = {:?} {:?}", n, n.len());
            }
        }
    }
}
#[test]
pub fn random_scenario_sized_test() {
    let path = "/home/pe/bla/db";
    let l0 = 1 << 20;
    std::fs::remove_file(path).unwrap_or(());
    let env = Env::new(&path, l0, 1).unwrap();
    let mut txn = Env::mut_txn_begin(&env).unwrap();
    let mut db = create_db::<MutTxn<&Env, ()>, U, V>(&mut txn).unwrap();
    use rand::{Rng, SeedableRng};
    let mut rng = rand::rngs::SmallRng::from_seed(*b"rc',.snjcg'sthomw,.vbw,.p84fcxjw");
    let mut ve: Vec<(U, V)> = Vec::with_capacity(100_000);
    use std::collections::HashMap;
    let mut h: HashMap<U, V> = HashMap::with_capacity(100_000);
    let mut refs = BTreeMap::new();
    for i in 0.. {
        let do_debug = i % 10_000_000 == 0;
        if do_debug {
            env_logger::try_init().unwrap_or(());
            info!("========== i = {:?} {:?}", i, db.db);
        }
        if rng.gen_range(0..4) == 3 {
            if let Some((k, v)) = ve.pop() {
                if do_debug {
                    debug!("del {:?} {:?}", k.0[0], v.0[0]);
                }
                assert!(del(&mut txn, &mut db, &k, Some(&v)).unwrap())
            }
        } else {
            let k = U([rng.gen(), rng.gen(), rng.gen()]);
            let v = V([rng.gen(), rng.gen(), rng.gen(), rng.gen(), rng.gen()]);
            if do_debug {
                debug!("put {:?} {:?}", k.0[0], v.0[0]);
            }
            put(&mut txn, &mut db, &k, &v).unwrap();
            ve.push((k, v));
            h.insert(k, v);
        }
        if do_debug {
            for (i, (k, v)) in ve.iter().enumerate() {
                if get(&txn, &db, k, None).unwrap() != Some((k, v)) {
                    panic!("test {:?} {:?} {:?}", i, k.0[0], v.0[0]);
                }
            }
            for x in iter(&txn, &db, None).unwrap() {
                let (k, v) = x.unwrap();
                if h.get(k) != Some(v) {
                    panic!("test {:?}", k);
                }
            }
            refs.clear();
            add_refs(&txn, &db, &mut refs).unwrap();
            check_free_mut(&mut txn, &refs);
            for (p, r) in refs.iter() {
                if *r >= 2 {
                    let rc = txn.rc(*p).unwrap();
                    if rc != *r as u64 {
                        panic!("p {:?} r {:?} {:?}", p, r, rc);
                    }
                } else {
                    assert_eq!(txn.rc(*p).unwrap(), 0);
                }
            }
        }
    }
}
#[test]
pub fn random_scenario_unsized_test() {
    let path = "/home/pe/bla/udb";
    let l0 = 1 << 20;
    std::fs::remove_file(path).unwrap_or(());
    let env = Env::new(&path, l0, 1).unwrap();
    let mut txn = Env::mut_txn_begin(&env).unwrap();
    let mut db = create_db_::<MutTxn<&Env, ()>, U, V, btree::page_unsized::Page<U, V>>(&mut txn).unwrap();
    use rand::{Rng, SeedableRng};
    let mut rng = rand::rngs::SmallRng::from_seed(*b"rc',.snjcg'sthomw,.vbw,.p84fcxjw");
    let mut ve: Vec<(U, V)> = Vec::with_capacity(100_000);
    use std::collections::HashMap;
    let mut h: HashMap<U, V> = HashMap::with_capacity(100_000);
    let mut refs = BTreeMap::new();
    for i in 0.. {
        let do_debug = true; // i % 10_000_000 == 0;
        if do_debug {
            env_logger::try_init().unwrap_or(());
            info!("========== i = {:?} {:?}", i, db.db);
        }
        if rng.gen_range(0..4) == 3 {
            if let Some((k, v)) = ve.pop() {
                if do_debug {
                    debug!("del {:?} {:?}", k.0[0], v.0[0]);
                }
                assert!(del(&mut txn, &mut db, &k, Some(&v)).unwrap())
            }
        } else {
            let k = U([rng.gen(), rng.gen(), rng.gen()]);
            let v = V([rng.gen(), rng.gen(), rng.gen(), rng.gen(), rng.gen()]);
            if do_debug {
                debug!("put {:?} {:?}", k.0[0], v.0[0]);
            }
            put(&mut txn, &mut db, &k, &v).unwrap();
            ve.push((k, v));
            h.insert(k, v);
        }
        if do_debug {
            for (i, (k, v)) in ve.iter().enumerate() {
                if get(&txn, &db, k, None).unwrap() != Some((k, v)) {
                    panic!("test {:?} {:?} {:?}", i, k.0[0], v.0[0]);
                }
            }
            for x in iter(&txn, &db, None).unwrap() {
                let (k, v) = x.unwrap();
                if h.get(k) != Some(v) {
                    panic!("test {:?}", k);
                }
            }
            refs.clear();
            add_refs(&txn, &db, &mut refs).unwrap();
            check_free_mut(&mut txn, &refs);
            for (p, r) in refs.iter() {
                if *r >= 2 {
                    let rc = txn.rc(*p).unwrap();
                    if rc != *r as u64 {
                        panic!("p {:?} r {:?} {:?}", p, r, rc);
                    }
                } else {
                    assert_eq!(txn.rc(*p).unwrap(), 0);
                }
            }
        }
    }

use log::*;

        debug!("FREEING OWNED PAGE {:?}", offset);

        debug!("FREEING OWNED PAGE {:?} {:x}", offset, offset);

        debug!("FREEING PAGE {:?}", offset);

        debug!("FREEING PAGE {:?} {:x}", offset, offset);

        let mut f = if let Some((f, ())) = curs.set_last(self)? {

        curs.set_last(self)?;
        let mut f = if let Some((f, ())) = curs.prev(self)? {

        btree::del::del_at_cursor(self, &mut db, &mut curs)?;

        assert!(btree::del::del(self, &mut db, &f, None)?);

            let rc = if let Some((rc, _)) = curs.set(self, &off, None)? {

            curs.set(self, &off, None)?;
            let rc = if let Some((rc, _)) = curs.current(self)? {

            debug!("incr rc {:?} {:?}", off, rc+1);

use log::*;

            GlobalHeader::from_le(&*(map as *const GlobalHeader)).n_roots as usize

            let g = &*(map as *const GlobalHeader);
            assert_eq!(g.version, CURRENT_VERSION);
            g.n_roots as usize

                info!("find_offset, i = {:?}/{:?}, extending, offset = {:?}, length0 = {:?}", i, mmaps.len(), offset, length0);

            let page_ptr = maps[0].ptr.add(root * PAGE_SIZE);
            let crc = (&*(page_ptr as *const GlobalHeader)).crc;
            let root_page = std::slice::from_raw_parts(page_ptr.add(8), PAGE_SIZE - 8);
            let mut h = HASHER.clone();
            h.update(root_page);
            if h.finalize() != crc {
                return Err(crate::CRCError {});
            }

            check_crc(maps[0].ptr.add(root * PAGE_SIZE))

        Ok(())

        debug!("SETTING CRC {:?}", (&*globptr).crc);

            check_crc(data)?;

    let crc = u32::from_le(*(p as *const u32));

    let globptr = p as *mut GlobalHeader;
    let crc = u32::from_le((&*globptr).crc);

    let data = std::slice::from_raw_parts(p.offset(4), PAGE_SIZE - 4);

    let data = std::slice::from_raw_parts(p.offset(8), PAGE_SIZE - 8);

    debug!("CHECKING CRC {:?} {:?}", crc_, crc);

#[cfg(not(feature = "crc32"))]
unsafe fn check_crc(_: *const u8) -> Result<(), crate::CRCError> {
    Ok(())
}

    debug!("CURSOR: {:?} {:?}", p.offset, cursor);

version = "1.0.1"

version = "1.1.2"

sanakirja-core = { path = "../sanakirja-core", version = "1.0.1" }

sanakirja-core = { path = "../sanakirja-core", version = "1.1.0" }

rand = "0.8"

rand = {version = "0.8", features = [ "small_rng" ] }