debug!("{:?}", cursor.pointer);

    debug!("put: {:?} {:?}", cursor.pointer, cursor.first_rc_level);

        cursor.pointer <= cursor.first_rc_level,

        cursor.pointer < cursor.first_rc_level,

        if cursor.pointer == cursor.first_rc_level {

        if cursor.pointer == cursor.first_rc_level + 1 {

                txn.decr_rc(freed ^ 1)?;

                txn.decr_rc(freed)?;

            debug!("new = {:?}", new);

            let l = header(page.as_page()).left_page() & !0xfff;
            let hdr = header_mut(&mut new);
            hdr.left_page = l.to_le();

}
pub fn get<'a, T: LoadPage, K: Representable<T>, V: Representable<T>, P: BTreePage<T, K, V>>(
    txn: &'a T,
    db: &Db<T, K, V, P>,
    k: &K,
    v: Option<&V>,
) -> Result<Option<(&'a K, &'a V)>, T::Error> {
    // Set the "cursor stack" by setting a skip list cursor in
    // each page from the root to the appropriate leaf.
    let mut last_match = None;
    let mut page = db.db;
    for _ in 0..cursor::N_CURSORS {
        let mut cursor = P::first_cursor(page.as_page());
        if let Ok((kk, vv, _)) = P::set_cursor(txn, page.as_page(), &mut cursor, k, v) {
            if v.is_some() {
                return Ok(Some((kk, vv)));
            }
            last_match = Some((kk, vv));
        } else if let Some((k, v, _)) = P::current(page.as_page(), &cursor) {
            unsafe { last_match = Some((
                core::mem::transmute(k),
                core::mem::transmute(v),
            )) }
        }
        let next_page = P::left_child(page.as_page(), &cursor);
        if next_page > 0 {
            page = txn.load_page(next_page)?;
        } else {
            break;
        }
    }
    Ok(last_match)

            debug!("p: {:?}", self.pointer);

            debug!("self.pointer = {:?}", self.pointer);

            debug!("page = {:?}, rc = {:?}", current.page, txn.rc(page.offset)?);

                debug!("first_rc_level = {:?}", self.pointer);

mod debug;

pub mod debug;

            if rc & 0xfff >= 2 {

            if rc > 1 {

                if rc > 2 {
                    btree::put(self, &mut rc_, &(rc - 1), &())?;
                }

            }
            if rc & 0xfff > 2 {
                btree::put(self, &mut rc_, &(rc - 1), &())?;
                self.rc = Some(rc_);

            } else {
                self.rc = Some(rc_)

        debug!("decr_rc_owned {:?}", off);

            if rc & 0xfff >= 2 {

            debug!("rc = {:?}", rc);
            if rc > 1 {

                if rc > 2 {
                    btree::put(self, &mut rc_, &(rc - 1), &())?;
                }

            }
            if rc & 0xfff > 2 {
                btree::put(self, &mut rc_, &(rc - 1), &())?;
                self.rc = Some(rc_);

            } else {
                self.rc = Some(rc_);

        debug!("incr_rc {:?}", off);

        } else {
            let mut rc = btree::create_db(self)?;
            debug!("put in RC: {:?} {:?}", rc, off|2);
            btree::put(self, &mut rc, &(off | 2), &())?;
            debug!("done");
            self.rc = Some(rc);

            let mut curs: btree::cursor::Cursor<Self, u64, (), btree::page::Page<u64, ()>> =
                btree::cursor::Cursor::new(rc);
            if let Some((rc, _)) = curs.set(self, Some((&page, None)))? {

            if let Some((rc, _)) = btree::get(self, rc, &page, None)? {