/// references to out-of-tree pages.

/// references.

    assert_eq!(k.align_offset(K::ALIGN), 0);

    let va = V::ALIGN;
    let v_off = (ks + va - 1) & !(va - 1);

    let v_off = (ks + V::ALIGN - 1) & !(V::ALIGN - 1);

                self.data.offset(8),

                self.data.add(8),

/// `CowPage` to avoid checking the "dirty" bit at running time.

/// `CowPage` to avoid checking the "dirty" bit at runtime.

            let crc = (self.0.data as *mut u32).offset(1);

            let crc = (self.0.data as *mut u32).add(1);

    // position `-1` has a right child (which is the left child of the
    // first element).

    // position `-1` has a right child (which is the first element's
    // left child).

        if c.cur < c.total as isize {
            c.cur += 1;
            true
        } else {
            false

        if c.cur >= c.total as isize {
            return false;

        c.cur += 1;
        true

        if c.cur > 0 {
            c.cur -= 1;
            true
        } else {
            c.cur = -1;
            false

        if c.cur < 0 {
            return false;

        c.cur -= 1;
        true

    // This is the first non-trivial method, let's explain it.

            // This means that the header may be followed by
            // padding. These are constants known at compile-time, by
            // the way, so `al` and `hdr` are optimised away by the
            // compiler.

            // This means that the header may be followed by padding
            // (in order to align the entries). These are constants
            // known at compile-time, so `al` and `hdr` are optimised
            // away by the compiler.

            // `f * cur` bytes after the padded header:

            // `f * cur` bytes after the padded header (because
            // `size_of` includes alignment padding).

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

            assert!(c.cur < c.total as isize && HDR as isize + c.cur * 8 - 8 <= 4088);

            assert!(c.cur < c.total as isize && HDR as isize + c.cur * 8 <= 4088);

                    // Just read the tuple, as we did multiple times
                    // before.

                    // Just read the tuple and return it.

    // leaf). This is implemented the `put` module.

    // leaf). This is implemented in the `put` module.

    unsafe fn put_mut(
        page: &mut MutPage,
        c: &mut Self::Cursor,
        k0: &K,
        v0: &V,
        r: u64,
    ) {

    unsafe fn put_mut(page: &mut MutPage, c: &mut Self::Cursor, k0: &K, v0: &V, r: u64) {

    unsafe fn set_left_child(
        page: &mut MutPage,
        c: &Self::Cursor,
        l: u64
    ) {

    unsafe fn set_left_child(page: &mut MutPage, c: &Self::Cursor, l: u64) {

        assert!(!c.is_leaf && c.cur >= 0 && (c.cur as usize) < c.total + 1);

        assert!(!c.is_leaf && c.cur >= 0 && (c.cur as usize) <= c.total);

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

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

    /// element. In that sense, this is not the symmetric of `next`.

    /// element. Note that this is not the symmetric of `next`.

    /// if `v0.is_none()`, and to `(k0, v0)` if `v0.is_some()`.

    /// if `v0.is_none()`, and to `(k0, v0)` if `v0.is_some()`.  If a
    /// match is found (on `k0` only if `v0.is_none()`, on `(k0, v0)`
    /// else), return the match along with the right child.
    ///
    /// Else (in the `Err` case of the `Result`), return the position
    /// at which `(k0, v0)` can be inserted.

    /// Splits the cursor into two cursors: the elements strictly
    /// before the current position, and the elements greater than or
    /// equal the current element.

    /// `replace`. The "double insertion" is only ever used when
    /// deleting, and when the right child of a deleted entry (in an
    /// internal node) has split while we were looking for a
    /// replacement for the deleted entry.

    /// `replace`. When `k1v1.is_some()`, we insert both `(k0, v0)`
    /// (as a replacement), followed by `(k1, v1)`. This is only ever
    /// used when deleting, and when the right child of a deleted
    /// entry (in an internal node) has split while we were looking
    /// for a replacement for the deleted entry.

    ) {
        unimplemented!()
    }

    );

    ) {
        unimplemented!()
    }

    );

        // Here, either rc > 1, or else `P::move_next` returned
        // `false`, meaning that the cursor is after the last element.

        // Here, either rc > 1 (in which case the only thing we need
        // to do in this iteration is to decrement the RC), or else
        // `P::move_next` returned `false`, meaning that the cursor is
        // after the last element (in which case we are done with this
        // page, and also need to decrement its RC, in order to free
        // it).

    /// Push the leftmost path starting at page `left_page` onto the
    /// stack.

    // An invariant of cursors, fundamental to understand the `next`
    // and `prev` functions below, is that the lower levels (in the
    // tree, upper levels on the stack) are the left children of the
    // cursor's position on a page.

    // An invariant of cursors, fundamental to understanding the
    // `next` and `prev` functions below, is that the lower levels (in
    // the tree, upper levels on the stack) are the left children of
    // the cursor's position on a page.

        // Set the "cursor stack" by setting a skip list cursor in
        // each page from the root to the appropriate leaf.

        // Set the "cursor stack" by setting a cursor in each page
        // on a path from the root to the appropriate leaf.

        // Start back from the bottom.

        // Start from the bottom of the stack, which is also the root
        // of the tree.