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

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

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

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

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

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

            debug!("last_matching {:?}", last_matching_page);

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

            if self.pointer == 0 {
                return Ok(None);
            } else {
                let current = unsafe { &mut *self.stack[self.pointer].as_mut_ptr() };
                if let Some(ref mut c) = current.cursor {
                    // We're inside the page, and have already
                    // processed the left child of the current page
                    // cursor.
                    if let Some((k, v, r)) = P::next(current.page.as_page(), c) {
                        if r > 0 {
                            self.pointer += 1;
                            self.stack[self.pointer] = MaybeUninit::new(PageCursor {
                                page: txn.load_page(r)?,
                                cursor: None,
                            })
                        }
                        return Ok(Some((& *k, & *v)));
                    } else if self.pointer > 1 {
                        self.pointer -= 1
                    } else {
                        return Ok(None);
                    }
                } else {
                    current.cursor = Some(P::first_cursor(current.page.as_page()));
                    // First element of a page (not a binding).
                    let cursor = current.cursor.as_ref().unwrap();
                    let left = P::left_child(current.page.as_page(), cursor);
                    debug!("left = {:?}", left);
                    // Then visit the right child (if any), i.e. push.
                    if left != 0 {

            let current = unsafe { &mut *self.stack[self.pointer].as_mut_ptr() };
            if let Some(ref mut c) = current.cursor {
                // We're inside the page, and have already
                // processed the left child of the current page
                // cursor.
                if let Some((k, v, r)) = P::next(current.page.as_page(), c) {
                    if r > 0 {

                            page: txn.load_page(left)?,

                            page: txn.load_page(r)?,

                    return Ok(Some((& *k, & *v)));
                } else if self.pointer > 1 {
                    self.pointer -= 1
                } else {
                    return Ok(None);
                }
            } else {
                current.cursor = Some(P::first_cursor(current.page.as_page()));
                // First element of a page (not a binding).
                let cursor = current.cursor.as_ref().unwrap();
                let left = P::left_child(current.page.as_page(), cursor);
                // Then visit the right child (if any), i.e. push.
                if left != 0 {
                    self.pointer += 1;
                    self.stack[self.pointer] = MaybeUninit::new(PageCursor {
                        page: txn.load_page(left)?,
                        cursor: None,
                    })

    free: CowPage,

    pub(crate) free: CowPage,