impl<T: AllocPage, K: Representable<T>, V: Representable<T>> super::BTreeMutPage<T, K, V>

impl<T: AllocPage + core::fmt::Debug, K: Representable<T> + core::fmt::Debug, V: Representable<T> + core::fmt::Debug> super::BTreeMutPage<T, K, V>

        debug!("del: {:?} {:?}", page, l);

                    let off = (p as *mut u64).offset(c.cur as isize - 1);

                    let off = (p.add(HDR) as *mut u64).offset(c.cur as isize - 1);

            hdr.set_n(u16::from_le((&*hdr).n) - 1);

            hdr.set_n(hdr.n() - 1);

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

    fn truncate_left<T, K: Representable<T>, V: Representable<T>>(page: &mut MutPage, n: usize) -> Option<(*const K, *const V)>;

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

    fn truncate_left<T, K: Representable<T>, V: Representable<T>>(page: &mut MutPage, n: usize) -> Option<(*const K, *const V)> {

                let mut swap: core::mem::MaybeUninit<Tuple<K, V>> = core::mem::MaybeUninit::uninit();
                core::ptr::copy(
                    page.0.data.add(hdr_size + (n-1) * f),
                    swap.as_mut_ptr() as *mut u8,
                    f,
                );

                    n * f,

                    (hdr_n as usize - n) * f,
                );
                core::ptr::copy(
                    swap.as_ptr() as *mut u8,
                    page.0.data.add(hdr_size + (hdr_n as usize - n) * f),
                    f,

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

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

            unsafe {
                Some(read::<T, K, V>(page.0.data.add(hdr_size + (hdr_n as usize - n) * f)))
            }

                    n * 2,

                    (hdr_n as usize - n) * 2,

            None

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

    fn truncate_left<T, K: Representable<T>, V: Representable<T>>(page: &mut MutPage, n: usize) -> Option<(*const K, *const V)> {

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

                (n + 1) * 8,

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

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

        debug!("truncate_left {:?} {:?}", hdr.left_page(), size);

        None

unsafe fn modify<T: LoadPage, K: Representable<T>, V: Representable<T>, L: Alloc>(

unsafe fn modify<T: LoadPage + core::fmt::Debug, K: Representable<T> + core::fmt::Debug, V: Representable<T> + core::fmt::Debug, L: Alloc>(

    debug!("modify {:?}", m);

unsafe fn merge<T: LoadPage, K: Representable<T>, V: Representable<T>, L: Alloc>(

unsafe fn merge<T: LoadPage + core::fmt::Debug, K: Representable<T> + core::fmt::Debug, V: Representable<T> + core::fmt::Debug, L: Alloc>(

fn rebalance<'a, T: AllocPage, K: Representable<T>, V: Representable<T>, L: Alloc>(

fn rebalance<'a, T: AllocPage + core::fmt::Debug, K: Representable<T> + core::fmt::Debug, V: Representable<T> + core::fmt::Debug, L: Alloc>(

fn put<'a, T: AllocPage, K: Representable<T>, V: Representable<T>, L: Alloc>(

fn put<'a, T: AllocPage + core::fmt::Debug, K: Representable<T> + core::fmt::Debug, V: Representable<T> + core::fmt::Debug, L: Alloc>(

fn split<'a, T: AllocPage, K: Representable<T>, V: Representable<T>, L: Alloc>(

fn split<'a, T: AllocPage + core::fmt::Debug, K: Representable<T> + core::fmt::Debug, V: Representable<T> + core::fmt::Debug, L: Alloc>(

    let n = hdr.n() + 1;

    let mut n = hdr.n();

    n += 1;

    let (split_key, split_value, mid_child, s1) = if u == k as usize {

    debug!("u = {:?}, k = {:?} {:?} {:?}", u, k, s0, s1);
    let (mut split_key, mut split_value, mid_child, s1) = if u == k as usize {

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

        debug!("k = {:?}, v = {:?} r = {:?}", k, v, r);
        debug!("k = {:?}", k as *const K as *const u8);
        (k, v, r, s1b)

            // Insertion in the middle.

            // Insertion in the middle:
            // - `l` becomes the right child of the last element on `left`.
            L::set_right_child(&mut left, k as isize - 1, l);
            // - `r` (i.e. `mid_child`) becomes the left child of `right`.

        let mid = k as usize - u as usize;
        let (s0a, s0b) = s0.split_at(mid);

        let ll = header(page.as_page()).left_page() & !0xfff;
        L::set_right_child(&mut left, -1, ll);
        let (s0a, s0b) = s0.split_at(u as usize);

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

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

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

            if let Some((k, v)) = L::truncate_left::<T, K, V>(&mut right, k as usize + 1) {
                unsafe {
                    split_key = &*k;
                    split_value = &*v;
                }
            }

            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,
            }))

            if m.skip_first {
                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,
                }))
            } else {
                Ok(Put::Ok(Self::update_left_child(txn, m.page, m.mutable, &m.c1, m.l)?))
            }

#[derive(Debug)]

pub fn fork_db<
    T: AllocPage,
    K: Representable<T>,
    V: Representable<T>,
    P: BTreeMutPage<T, K, V>,
>(
    txn: &mut T,
    db: &Db<T, K, V, P>,
) -> Result<Db<T, K, V, P>, T::Error> {
    txn.incr_rc(db.db.offset)?;
    Ok(Db {
        db: db.db,
        marker: core::marker::PhantomData,
    })
}

        match P::merge_or_rebalance(txn, &mut concat)? {

        let merge = P::merge_or_rebalance(txn, &mut concat)?;
        debug!("merge = {:?}", merge);
        match merge {

        debug!("single child {:?}", d);

        debug!("modify {:?}", last_op);

use log::*;
use sanakirja::environment::*;
use sanakirja_core::btree::*;
use sanakirja_core::btree;
use sanakirja_core::*;
// mod parallel_benchmark;
mod debug;
fn main() {
    env_logger::init();
    main::main();
    // main::parallel_benchmark();
}
#[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>, ()>;
mod main {
    use super::*;
    #[test]
    pub fn main() {
        env_logger::try_init().unwrap_or(());
        let env = Env::new_anon(409600000).unwrap();
        let mut txn = Env::mut_txn_begin(&env).unwrap();
        let now = std::time::SystemTime::now();
        for i in 0..n {
            debug!("put {:?}", i);
        }
        println!("moi: {:?}", now.elapsed());
        let mut btree = std::collections::BTreeMap::new();
        let now = std::time::SystemTime::now();
        for i in 0..n {
        }
        println!("std: {:?}", now.elapsed());
        /*
        std::mem::forget(txn);
        {
            let env = EnvBuilder::new()
                .map_size(1 << 27)
                .open("test-lmdb", 0o777)
                .unwrap();
            let db_handle = env.get_default_db(DbFlags::empty()).unwrap();
            let txn = env.new_transaction().unwrap();
            {
                let db = txn.bind(&db_handle); // get a database bound to this transaction
                let now = std::time::SystemTime::now();
                for i in 0..n {
                    db.set(&(i * i), &(i * i * i)).unwrap();
                }
                println!("lmdb: {:?}", now.elapsed());
            }
        }
         */
    }
}
        */
            btree.insert(i * i, i * i * i);
        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);
        /*
            let a = A([i * i * i; 100], std::marker::PhantomData);
            put(&mut txn, &mut db, &((i * i) % 1_000_000), &a).unwrap();
        let mut db = create_db::<MutTxn<&Env<Exclusive>, ()>, u64, A<T>, B<T>>(&mut txn).unwrap();
        let n = 501;
type B<T> = btree::page::Page<u64, A<T>>;

#[cfg(test)]
mod tests;
mod debug;

            let root = env.root.lock();

            let mut root = env.root.lock();

            let mut root = env.root.lock();