/// Represents the result of a merge or rebalance, without touching
/// the parent of the merge/rebalance.

        // New merged page.

        // Pages freed by the merge (0 meaning "no page").

        // New middle key.

        // New middle value.

        // Do `k` and `v` come from a page shared with another tree?

        // New left page.

        // New right page.

        // Pages freed by the rebalance (0 meaning "no page").

/// Represents a page with modifications from a merge.

    // If a rebalance causes a split, we might need to insert an entry
    // after the replacement.

impl<'a, K: Representable + ?Sized, V: Representable + ?Sized, P: BTreePage<K, V>>
    ModifiedPage<'a, K, V, P>
{
    pub fn single_child(&self) -> Option<u64> {
        let mut c1 = self.c1.clone();
        if self.skip_first {
            P::move_next(&mut c1);
        }
        debug!(
            "single_child: {:?} {:?} {:?} {:?}",
            self.page, self.c0, c1, self.ins
        );
        if P::is_empty(self.page.as_page(), &self.c0)
            && self.ins.is_none()
            && P::is_empty(self.page.as_page(), &c1)
        {
            Some(self.l)
        } else {
            None
        }
    }
}

/// Represents the concatenation of a modified page and one of its
/// sibling (left or right).

    /// Modified page.
    pub modified: ModifiedPage<'a, K, V, P>,
    /// Middle element.

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

    /// Sibling of the modified page.

    // Is the modified field on the left or on the right of the
    // concatenation?

    /// Is the modified field on the left or on the right of the
    /// concatenation?

    /// Is the other page owned by this tree? If not, it means `other`
    /// is shared with another tree, and hence we need to increase the
    /// reference count of entries coming from `other`.

/// A database, which is essentially just a page offset along with markers.

/// A database of sized values.

/// A database of unsized values.
pub type UDb<K, V> = Db_<K, V, page_unsized::Page<K, V>>;

    /// Load a database from a page offset.

/// Create a database with an arbitrary page implementation.

/// Create a database for sized keys and values.

pub fn fork_db_<

/// Fork a database.
pub fn fork_db<

pub fn fork_db<
    T: AllocPage + core::fmt::Debug,
    K: Representable + core::fmt::Debug,
    V: Representable + core::fmt::Debug,
>(
    txn: &mut T,
    db: &Db<K, V>,
) -> Result<Db<K, V>, T::Error> {
    fork_db_(txn, db)
}

/// Get the first entry of a database greater than or equal to `k` (or
/// to `(k, v)` if `v.is_some()`).

/// Drop a database recursively, dropping all referenced keys and
/// values that aren't shared with other databases.

    drop_::<T, K, V, P>(txn, txn.load_page(db.db)?.as_page())
}

    use core::mem::MaybeUninit;

fn drop_<T: AllocPage, K: Representable + ?Sized, V: Representable + ?Sized, P: BTreePage<K, V>>(
    txn: &mut T,
    p: Page,
) -> Result<(), T::Error> {
    let rc = if P::is_dirty(p) {
        txn.decr_rc_owned(p.offset)?
    } else {
        txn.decr_rc(p.offset)?
    };
    if rc == 0 {
        let mut cursor = P::cursor_before(p);
        let left_page = P::right_child(p, &cursor);
        if left_page == 0 {
            return Ok(());
        }
        drop_::<T, K, V, P>(txn, txn.load_page(left_page)?.as_page())?;
        while let Some((k, v, r)) = P::next(txn, p, &mut cursor) {
            for o in k.page_offsets().chain(v.page_offsets()) {
                txn.decr_rc(o)?;

    let mut stack: [MaybeUninit<cursor::PageCursor<K, V, P>>; cursor::N_CURSORS] =
        [MaybeUninit::uninit(); cursor::N_CURSORS];
    let page = txn.load_page(db.db)?;
    stack[0] = MaybeUninit::new(cursor::PageCursor {
        page,
        cursor: P::cursor_before(page.as_page()),
    });
    let mut ptr = 0;
    loop {
        let cur = unsafe { &mut *stack[ptr].as_mut_ptr() };
        let rc = txn.rc(cur.page.offset)?;
        if rc <= 1 {
            if let Some((k, v, _)) = P::current(txn, cur.page.as_page(), &cur.cursor) {
                for o in k.page_offsets().chain(v.page_offsets()) {
                    txn.decr_rc(o)?;
                }

            drop_::<T, K, V, P>(txn, txn.load_page(r)?.as_page())?;

            if P::move_next(&mut cur.cursor) {
                let r = P::left_child(cur.page.as_page(), &cur.cursor);
                if r > 0 {
                    ptr += 1;
                    let page = txn.load_page(r)?;
                    stack[ptr] = MaybeUninit::new(cursor::PageCursor {
                        page,
                        cursor: P::cursor_before(page.as_page()),
                    })
                }
                continue
            }

        if P::is_dirty(cur.page.as_page()) {
            txn.decr_rc_owned(cur.page.offset)?;
        } else {
            txn.decr_rc(cur.page.offset)?;
        }
        if ptr == 0 {
            break
        } else {
            ptr -= 1;
        }

    if let Some(d) = last_op.single_child() {

    if let Some(d) = single_child(&last_op) {

fn single_child<K: Representable+?Sized, V: Representable+?Sized, P: BTreeMutPage<K, V>>(m: &ModifiedPage<K, V, P>) -> Option<u64> {
    let mut c1 = m.c1.clone();
    if m.skip_first {
        P::move_next(&mut c1);
    }
    debug!(
        "single_child: {:?} {:?} {:?} {:?}",
        m.page,
        m.c0, c1, m.ins
    );
    if P::is_empty(m.page.as_page(), &m.c0)
        && m.ins.is_none()
        && P::is_empty(m.page.as_page(), &c1)
    {
        Some(m.l)
    } else {
        None
    }
}

    let db2 = fork_db(&mut txn, &db).unwrap();

    let _db2 = fork_db(&mut txn, &db).unwrap();

#[test]
pub fn fork_drop() {
    env_logger::try_init().unwrap_or(());
    let env = Env::new_anon(409600000, 1).unwrap();
    let mut txn = Env::mut_txn_begin(&env).unwrap();
    let mut db: Db<u64, u64> = create_db(&mut txn).unwrap();
    let n = 1000 as u64;
    let i0 = 10 as u64;
    let mut values = Vec::with_capacity(n as usize);
    for i in 0..n {
        put(&mut txn, &mut db, &i, &i).unwrap();
        if i != i0 {
            values.push(i);
        }
    }
    let db2 = fork_db(&mut txn, &db).unwrap();
    put(&mut txn, &mut db, &n, &n).unwrap();
    crate::debug::debug(&txn, &[&db, &db2], "debug1", true);
    drop(&mut txn, db2).unwrap();
    crate::debug::debug(&txn, &[&db], "debug2", true);
    let mut refs = BTreeMap::new();
    add_refs(&txn, &db, &mut refs).unwrap();
    let mut err = 0;
    for (p, r) in refs.iter() {
        println!("{:?} {:?}", p, r);
        if *r >= 2 {
            error!("{:?} {:?} {:?}", p, txn.rc(*p).unwrap(), *r);
            err += 1;
        } else {
            if txn.rc(*p).unwrap() != 0 {
                error!("{:?} {:?} 0", p, txn.rc(*p).unwrap());
                err += 1;
            }
        }
    }
    assert_eq!(err, 0);
}