diff --git a/src/btree/bt_curnext.c b/src/btree/bt_curnext.c
index 63b2e2abebc..70b3ba56e31 100644
--- a/src/btree/bt_curnext.c
+++ b/src/btree/bt_curnext.c
@@ -86,10 +86,10 @@ __cursor_fix_next(WT_CURSOR_BTREE *cbt, bool newpage)
 
 	/* Initialize for each new page. */
 	if (newpage) {
-		cbt->last_standard_recno = __col_fix_last_recno(page);
+		cbt->last_standard_recno = __col_fix_last_recno(cbt->ref);
 		if (cbt->last_standard_recno == 0)
 			return (WT_NOTFOUND);
-		__cursor_set_recno(cbt, page->pg_fix_recno);
+		__cursor_set_recno(cbt, cbt->ref->ref_recno);
 		goto new_page;
 	}
 
@@ -107,7 +107,7 @@ new_page:
 		cbt->ins = NULL;
 	upd = cbt->ins == NULL ? NULL : __wt_txn_read(session, cbt->ins->upd);
 	if (upd == NULL) {
-		cbt->v = __bit_getv_recno(page, cbt->recno, btree->bitcnt);
+		cbt->v = __bit_getv_recno(cbt->ref, cbt->recno, btree->bitcnt);
 		val->data = &cbt->v;
 	} else
 		val->data = WT_UPDATE_DATA(upd);
@@ -179,10 +179,10 @@ __cursor_var_next(WT_CURSOR_BTREE *cbt, bool newpage)
 
 	/* Initialize for each new page. */
 	if (newpage) {
-		cbt->last_standard_recno = __col_var_last_recno(page);
+		cbt->last_standard_recno = __col_var_last_recno(cbt->ref);
 		if (cbt->last_standard_recno == 0)
 			return (WT_NOTFOUND);
-		__cursor_set_recno(cbt, page->pg_var_recno);
+		__cursor_set_recno(cbt, cbt->ref->ref_recno);
 		goto new_page;
 	}
 
@@ -194,7 +194,7 @@ __cursor_var_next(WT_CURSOR_BTREE *cbt, bool newpage)
 
 new_page:	/* Find the matching WT_COL slot. */
 		if ((cip =
-		    __col_var_search(page, cbt->recno, &rle_start)) == NULL)
+		    __col_var_search(cbt->ref, cbt->recno, &rle_start)) == NULL)
 			return (WT_NOTFOUND);
 		cbt->slot = WT_COL_SLOT(page, cip);
 
@@ -558,7 +558,8 @@ __wt_btcur_iterate_setup(WT_CURSOR_BTREE *cbt)
 		 * page.
 		 */
 		cbt->last_standard_recno = page->type == WT_PAGE_COL_VAR ?
-		    __col_var_last_recno(page) : __col_fix_last_recno(page);
+		    __col_var_last_recno(cbt->ref) :
+		    __col_fix_last_recno(cbt->ref);
 
 		/* If we're traversing the append list, set the reference. */
 		if (cbt->ins_head != NULL &&
diff --git a/src/btree/bt_curprev.c b/src/btree/bt_curprev.c
index 7475c0f1312..872f648446c 100644
--- a/src/btree/bt_curprev.c
+++ b/src/btree/bt_curprev.c
@@ -128,12 +128,10 @@ static inline int
 __cursor_fix_append_prev(WT_CURSOR_BTREE *cbt, bool newpage)
 {
 	WT_ITEM *val;
-	WT_PAGE *page;
 	WT_SESSION_IMPL *session;
 	WT_UPDATE *upd;
 
 	session = (WT_SESSION_IMPL *)cbt->iface.session;
-	page = cbt->ref->page;
 	val = &cbt->iface.value;
 
 	if (newpage) {
@@ -176,8 +174,8 @@ __cursor_fix_append_prev(WT_CURSOR_BTREE *cbt, bool newpage)
 		 * to a record number matching the first record on the page.
 		 */
 		if (cbt->ins == NULL &&
-		    (cbt->recno == page->pg_fix_recno ||
-		    __col_fix_last_recno(page) != 0))
+		    (cbt->recno == cbt->ref->ref_recno ||
+		    __col_fix_last_recno(cbt->ref) != 0))
 			return (WT_NOTFOUND);
 	}
 
@@ -234,7 +232,7 @@ __cursor_fix_prev(WT_CURSOR_BTREE *cbt, bool newpage)
 
 	/* Initialize for each new page. */
 	if (newpage) {
-		cbt->last_standard_recno = __col_fix_last_recno(page);
+		cbt->last_standard_recno = __col_fix_last_recno(cbt->ref);
 		if (cbt->last_standard_recno == 0)
 			return (WT_NOTFOUND);
 		__cursor_set_recno(cbt, cbt->last_standard_recno);
@@ -242,7 +240,7 @@ __cursor_fix_prev(WT_CURSOR_BTREE *cbt, bool newpage)
 	}
 
 	/* Move to the previous entry and return the item. */
-	if (cbt->recno == page->pg_fix_recno)
+	if (cbt->recno == cbt->ref->ref_recno)
 		return (WT_NOTFOUND);
 	__cursor_set_recno(cbt, cbt->recno - 1);
 
@@ -255,7 +253,7 @@ new_page:
 		cbt->ins = NULL;
 	upd = cbt->ins == NULL ? NULL : __wt_txn_read(session, cbt->ins->upd);
 	if (upd == NULL) {
-		cbt->v = __bit_getv_recno(page, cbt->recno, btree->bitcnt);
+		cbt->v = __bit_getv_recno(cbt->ref, cbt->recno, btree->bitcnt);
 		val->data = &cbt->v;
 	} else
 		val->data = WT_UPDATE_DATA(upd);
@@ -327,7 +325,7 @@ __cursor_var_prev(WT_CURSOR_BTREE *cbt, bool newpage)
 
 	/* Initialize for each new page. */
 	if (newpage) {
-		cbt->last_standard_recno = __col_var_last_recno(page);
+		cbt->last_standard_recno = __col_var_last_recno(cbt->ref);
 		if (cbt->last_standard_recno == 0)
 			return (WT_NOTFOUND);
 		__cursor_set_recno(cbt, cbt->last_standard_recno);
@@ -338,12 +336,12 @@ __cursor_var_prev(WT_CURSOR_BTREE *cbt, bool newpage)
 	for (;;) {
 		__cursor_set_recno(cbt, cbt->recno - 1);
 
-new_page:	if (cbt->recno < page->pg_var_recno)
+new_page:	if (cbt->recno < cbt->ref->ref_recno)
 			return (WT_NOTFOUND);
 
 		/* Find the matching WT_COL slot. */
 		if ((cip =
-		    __col_var_search(page, cbt->recno, &rle_start)) == NULL)
+		    __col_var_search(cbt->ref, cbt->recno, &rle_start)) == NULL)
 			return (WT_NOTFOUND);
 		cbt->slot = WT_COL_SLOT(page, cip);
 
diff --git a/src/btree/bt_cursor.c b/src/btree/bt_cursor.c
index 1f3ac443495..839a829b960 100644
--- a/src/btree/bt_cursor.c
+++ b/src/btree/bt_cursor.c
@@ -164,7 +164,7 @@ __cursor_valid(WT_CURSOR_BTREE *cbt, WT_UPDATE **updp)
 		 * column-store pages don't have slots, but map one-to-one to
 		 * keys, check for retrieval past the end of the page.
 		 */
-		if (cbt->recno >= page->pg_fix_recno + page->pg_fix_entries)
+		if (cbt->recno >= cbt->ref->ref_recno + page->pg_fix_entries)
 			return (false);
 
 		/*
diff --git a/src/btree/bt_debug.c b/src/btree/bt_debug.c
index 5461c205b95..c4ee0d79606 100644
--- a/src/btree/bt_debug.c
+++ b/src/btree/bt_debug.c
@@ -36,17 +36,17 @@ static int  __debug_config(WT_SESSION_IMPL *, WT_DBG *, const char *);
 static int  __debug_dsk_cell(WT_DBG *, const WT_PAGE_HEADER *);
 static void __debug_dsk_col_fix(WT_DBG *, const WT_PAGE_HEADER *);
 static void __debug_item(WT_DBG *, const char *, const void *, size_t);
-static int  __debug_page(WT_DBG *, WT_PAGE *, uint32_t);
-static void __debug_page_col_fix(WT_DBG *, WT_PAGE *);
+static int  __debug_page(WT_DBG *, WT_REF *, uint32_t);
+static void __debug_page_col_fix(WT_DBG *, WT_REF *);
 static int  __debug_page_col_int(WT_DBG *, WT_PAGE *, uint32_t);
-static int  __debug_page_col_var(WT_DBG *, WT_PAGE *);
-static int  __debug_page_metadata(WT_DBG *, WT_PAGE *);
+static int  __debug_page_col_var(WT_DBG *, WT_REF *);
+static int  __debug_page_metadata(WT_DBG *, WT_REF *);
 static int  __debug_page_row_int(WT_DBG *, WT_PAGE *, uint32_t);
 static int  __debug_page_row_leaf(WT_DBG *, WT_PAGE *);
 static void __debug_ref(WT_DBG *, WT_REF *);
 static void __debug_row_skip(WT_DBG *, WT_INSERT_HEAD *);
 static int  __debug_tree(
-	WT_SESSION_IMPL *, WT_BTREE *, WT_PAGE *, const char *, uint32_t);
+	WT_SESSION_IMPL *, WT_BTREE *, WT_REF *, const char *, uint32_t);
 static void __debug_update(WT_DBG *, WT_UPDATE *, bool);
 static void __dmsg(WT_DBG *, const char *, ...)
 	WT_GCC_FUNC_DECL_ATTRIBUTE((format (printf, 2, 3)));
@@ -498,10 +498,10 @@ __wt_debug_tree_shape(
  */
 int
 __wt_debug_tree_all(
-    WT_SESSION_IMPL *session, WT_BTREE *btree, WT_PAGE *page, const char *ofile)
+    WT_SESSION_IMPL *session, WT_BTREE *btree, WT_REF *ref, const char *ofile)
 {
 	return (__debug_tree(session,
-	    btree, page, ofile, WT_DEBUG_TREE_LEAF | WT_DEBUG_TREE_WALK));
+	    btree, ref, ofile, WT_DEBUG_TREE_LEAF | WT_DEBUG_TREE_WALK));
 }
 
 /*
@@ -513,9 +513,9 @@ __wt_debug_tree_all(
  */
 int
 __wt_debug_tree(
-    WT_SESSION_IMPL *session, WT_BTREE *btree, WT_PAGE *page, const char *ofile)
+    WT_SESSION_IMPL *session, WT_BTREE *btree, WT_REF *ref, const char *ofile)
 {
-	return (__debug_tree(session, btree, page, ofile, WT_DEBUG_TREE_WALK));
+	return (__debug_tree(session, btree, ref, ofile, WT_DEBUG_TREE_WALK));
 }
 
 /*
@@ -523,7 +523,7 @@ __wt_debug_tree(
  *	Dump the in-memory information for a page.
  */
 int
-__wt_debug_page(WT_SESSION_IMPL *session, WT_PAGE *page, const char *ofile)
+__wt_debug_page(WT_SESSION_IMPL *session, WT_REF *ref, const char *ofile)
 {
 	WT_DBG *ds, _ds;
 	WT_DECL_RET;
@@ -533,7 +533,7 @@ __wt_debug_page(WT_SESSION_IMPL *session, WT_PAGE *page, const char *ofile)
 	ds = &_ds;
 	WT_RET(__debug_config(session, ds, ofile));
 
-	ret = __debug_page(ds, page, WT_DEBUG_TREE_LEAF);
+	ret = __debug_page(ds, ref, WT_DEBUG_TREE_LEAF);
 
 	__dmsg_wrapup(ds);
 
@@ -549,9 +549,8 @@ __wt_debug_page(WT_SESSION_IMPL *session, WT_PAGE *page, const char *ofile)
  *	in this function
  */
 static int
-__debug_tree(
-    WT_SESSION_IMPL *session, WT_BTREE *btree,
-    WT_PAGE *page, const char *ofile, uint32_t flags)
+__debug_tree(WT_SESSION_IMPL *session,
+    WT_BTREE *btree, WT_REF *ref, const char *ofile, uint32_t flags)
 {
 	WT_DBG *ds, _ds;
 	WT_DECL_RET;
@@ -560,10 +559,10 @@ __debug_tree(
 	WT_RET(__debug_config(session, ds, ofile));
 
 	/* A NULL page starts at the top of the tree -- it's a convenience. */
-	if (page == NULL)
-		page = btree->root.page;
+	if (ref == NULL)
+		ref = &btree->root;
 
-	WT_WITH_BTREE(session, btree, ret = __debug_page(ds, page, flags));
+	WT_WITH_BTREE(session, btree, ret = __debug_page(ds, ref, flags));
 
 	__dmsg_wrapup(ds);
 
@@ -575,7 +574,7 @@ __debug_tree(
  *	Dump the in-memory information for an in-memory page.
  */
 static int
-__debug_page(WT_DBG *ds, WT_PAGE *page, uint32_t flags)
+__debug_page(WT_DBG *ds, WT_REF *ref, uint32_t flags)
 {
 	WT_DECL_RET;
 	WT_SESSION_IMPL *session;
@@ -583,32 +582,32 @@ __debug_page(WT_DBG *ds, WT_PAGE *page, uint32_t flags)
 	session = ds->session;
 
 	/* Dump the page metadata. */
-	WT_WITH_PAGE_INDEX(session, ret = __debug_page_metadata(ds, page));
+	WT_WITH_PAGE_INDEX(session, ret = __debug_page_metadata(ds, ref));
 	WT_RET(ret);
 
 	/* Dump the page. */
-	switch (page->type) {
+	switch (ref->page->type) {
 	case WT_PAGE_COL_FIX:
 		if (LF_ISSET(WT_DEBUG_TREE_LEAF))
-			__debug_page_col_fix(ds, page);
+			__debug_page_col_fix(ds, ref);
 		break;
 	case WT_PAGE_COL_INT:
 		WT_WITH_PAGE_INDEX(session,
-		    ret = __debug_page_col_int(ds, page, flags));
+		    ret = __debug_page_col_int(ds, ref->page, flags));
 		WT_RET(ret);
 		break;
 	case WT_PAGE_COL_VAR:
 		if (LF_ISSET(WT_DEBUG_TREE_LEAF))
-			WT_RET(__debug_page_col_var(ds, page));
+			WT_RET(__debug_page_col_var(ds, ref));
 		break;
 	case WT_PAGE_ROW_INT:
 		WT_WITH_PAGE_INDEX(session,
-		    ret = __debug_page_row_int(ds, page, flags));
+		    ret = __debug_page_row_int(ds, ref->page, flags));
 		WT_RET(ret);
 		break;
 	case WT_PAGE_ROW_LEAF:
 		if (LF_ISSET(WT_DEBUG_TREE_LEAF))
-			WT_RET(__debug_page_row_leaf(ds, page));
+			WT_RET(__debug_page_row_leaf(ds, ref->page));
 		break;
 	WT_ILLEGAL_VALUE(session);
 	}
@@ -621,30 +620,32 @@ __debug_page(WT_DBG *ds, WT_PAGE *page, uint32_t flags)
  *	Dump an in-memory page's metadata.
  */
 static int
-__debug_page_metadata(WT_DBG *ds, WT_PAGE *page)
+__debug_page_metadata(WT_DBG *ds, WT_REF *ref)
 {
+	WT_PAGE *page;
 	WT_PAGE_INDEX *pindex;
 	WT_PAGE_MODIFY *mod;
 	WT_SESSION_IMPL *session;
 	uint32_t entries;
 
 	session = ds->session;
+	page = ref->page;
 	mod = page->modify;
 
 	__dmsg(ds, "%p", page);
 
 	switch (page->type) {
 	case WT_PAGE_COL_INT:
-		__dmsg(ds, " recno %" PRIu64, page->pg_intl_recno);
+		__dmsg(ds, " recno %" PRIu64, ref->ref_recno);
 		WT_INTL_INDEX_GET(session, page, pindex);
 		entries = pindex->entries;
 		break;
 	case WT_PAGE_COL_FIX:
-		__dmsg(ds, " recno %" PRIu64, page->pg_fix_recno);
+		__dmsg(ds, " recno %" PRIu64, ref->ref_recno);
 		entries = page->pg_fix_entries;
 		break;
 	case WT_PAGE_COL_VAR:
-		__dmsg(ds, " recno %" PRIu64, page->pg_var_recno);
+		__dmsg(ds, " recno %" PRIu64, ref->ref_recno);
 		entries = page->pg_var_entries;
 		break;
 	case WT_PAGE_ROW_INT:
@@ -707,10 +708,11 @@ __debug_page_metadata(WT_DBG *ds, WT_PAGE *page)
  *	Dump an in-memory WT_PAGE_COL_FIX page.
  */
 static void
-__debug_page_col_fix(WT_DBG *ds, WT_PAGE *page)
+__debug_page_col_fix(WT_DBG *ds, WT_REF *ref)
 {
 	WT_BTREE *btree;
 	WT_INSERT *ins;
+	WT_PAGE *page;
 	const WT_PAGE_HEADER *dsk;
 	WT_SESSION_IMPL *session;
 	uint64_t recno;
@@ -721,8 +723,9 @@ __debug_page_col_fix(WT_DBG *ds, WT_PAGE *page)
 
 	session = ds->session;
 	btree = S2BT(session);
+	page = ref->page;
 	dsk = page->dsk;
-	recno = page->pg_fix_recno;
+	recno = ref->ref_recno;
 
 	if (dsk != NULL) {
 		ins = WT_SKIP_FIRST(WT_COL_UPDATE_SINGLE(page));
@@ -767,7 +770,7 @@ __debug_page_col_int(WT_DBG *ds, WT_PAGE *page, uint32_t flags)
 	session = ds->session;
 
 	WT_INTL_FOREACH_BEGIN(session, page, ref) {
-		__dmsg(ds, "\trecno %" PRIu64 "\n", ref->key.recno);
+		__dmsg(ds, "\trecno %" PRIu64 "\n", ref->ref_recno);
 		__debug_ref(ds, ref);
 	} WT_INTL_FOREACH_END;
 
@@ -775,7 +778,7 @@ __debug_page_col_int(WT_DBG *ds, WT_PAGE *page, uint32_t flags)
 		WT_INTL_FOREACH_BEGIN(session, page, ref) {
 			if (ref->state == WT_REF_MEM) {
 				__dmsg(ds, "\n");
-				WT_RET(__debug_page(ds, ref->page, flags));
+				WT_RET(__debug_page(ds, ref, flags));
 			}
 		} WT_INTL_FOREACH_END;
 
@@ -787,18 +790,20 @@ __debug_page_col_int(WT_DBG *ds, WT_PAGE *page, uint32_t flags)
  *	Dump an in-memory WT_PAGE_COL_VAR page.
  */
 static int
-__debug_page_col_var(WT_DBG *ds, WT_PAGE *page)
+__debug_page_col_var(WT_DBG *ds, WT_REF *ref)
 {
 	WT_CELL *cell;
 	WT_CELL_UNPACK *unpack, _unpack;
 	WT_COL *cip;
 	WT_INSERT_HEAD *update;
+	WT_PAGE *page;
 	uint64_t recno, rle;
 	uint32_t i;
 	char tag[64];
 
 	unpack = &_unpack;
-	recno = page->pg_var_recno;
+	page = ref->page;
+	recno = ref->ref_recno;
 
 	WT_COL_FOREACH(page, cip, i) {
 		if ((cell = WT_COL_PTR(page, cip)) == NULL) {
@@ -849,7 +854,7 @@ __debug_page_row_int(WT_DBG *ds, WT_PAGE *page, uint32_t flags)
 		WT_INTL_FOREACH_BEGIN(session, page, ref) {
 			if (ref->state == WT_REF_MEM) {
 				__dmsg(ds, "\n");
-				WT_RET(__debug_page(ds, ref->page, flags));
+				WT_RET(__debug_page(ds, ref, flags));
 			}
 		} WT_INTL_FOREACH_END;
 	return (0);
diff --git a/src/btree/bt_handle.c b/src/btree/bt_handle.c
index 02eea9c2f0c..ba545859d07 100644
--- a/src/btree/bt_handle.c
+++ b/src/btree/bt_handle.c
@@ -371,7 +371,7 @@ __wt_root_ref_init(WT_REF *root_ref, WT_PAGE *root, bool is_recno)
 	root_ref->page = root;
 	root_ref->state = WT_REF_MEM;
 
-	root_ref->key.recno = is_recno ? 1 : WT_RECNO_OOB;
+	root_ref->ref_recno = is_recno ? 1 : WT_RECNO_OOB;
 
 	root->pg_intl_parent_ref = root_ref;
 }
@@ -495,7 +495,7 @@ __btree_tree_open_empty(WT_SESSION_IMPL *session, bool creation)
 	case BTREE_COL_FIX:
 	case BTREE_COL_VAR:
 		WT_ERR(__wt_page_alloc(
-		    session, WT_PAGE_COL_INT, 1, 1, true, &root));
+		    session, WT_PAGE_COL_INT, 1, true, &root));
 		root->pg_intl_parent_ref = &btree->root;
 
 		pindex = WT_INTL_INDEX_GET_SAFE(root);
@@ -504,11 +504,11 @@ __btree_tree_open_empty(WT_SESSION_IMPL *session, bool creation)
 		ref->page = NULL;
 		ref->addr = NULL;
 		ref->state = WT_REF_DELETED;
-		ref->key.recno = 1;
+		ref->ref_recno = 1;
 		break;
 	case BTREE_ROW:
 		WT_ERR(__wt_page_alloc(
-		    session, WT_PAGE_ROW_INT, 0, 1, true, &root));
+		    session, WT_PAGE_ROW_INT, 1, true, &root));
 		root->pg_intl_parent_ref = &btree->root;
 
 		pindex = WT_INTL_INDEX_GET_SAFE(root);
@@ -524,7 +524,7 @@ __btree_tree_open_empty(WT_SESSION_IMPL *session, bool creation)
 
 	/* Bulk loads require a leaf page for reconciliation: create it now. */
 	if (F_ISSET(btree, WT_BTREE_BULK)) {
-		WT_ERR(__wt_btree_new_leaf_page(session, 1, &leaf));
+		WT_ERR(__wt_btree_new_leaf_page(session, &leaf));
 		ref->page = leaf;
 		ref->state = WT_REF_MEM;
 		WT_ERR(__wt_page_modify_init(session, leaf));
@@ -548,8 +548,7 @@ err:	if (leaf != NULL)
  *	Create an empty leaf page.
  */
 int
-__wt_btree_new_leaf_page(
-    WT_SESSION_IMPL *session, uint64_t recno, WT_PAGE **pagep)
+__wt_btree_new_leaf_page(WT_SESSION_IMPL *session, WT_PAGE **pagep)
 {
 	WT_BTREE *btree;
 
@@ -558,15 +557,15 @@ __wt_btree_new_leaf_page(
 	switch (btree->type) {
 	case BTREE_COL_FIX:
 		WT_RET(__wt_page_alloc(
-		    session, WT_PAGE_COL_FIX, recno, 0, false, pagep));
+		    session, WT_PAGE_COL_FIX, 0, false, pagep));
 		break;
 	case BTREE_COL_VAR:
 		WT_RET(__wt_page_alloc(
-		    session, WT_PAGE_COL_VAR, recno, 0, false, pagep));
+		    session, WT_PAGE_COL_VAR, 0, false, pagep));
 		break;
 	case BTREE_ROW:
 		WT_RET(__wt_page_alloc(
-		    session, WT_PAGE_ROW_LEAF, WT_RECNO_OOB, 0, false, pagep));
+		    session, WT_PAGE_ROW_LEAF, 0, false, pagep));
 		break;
 	WT_ILLEGAL_VALUE(session);
 	}
@@ -639,7 +638,7 @@ __btree_get_last_recno(WT_SESSION_IMPL *session)
 
 	page = next_walk->page;
 	btree->last_recno = page->type == WT_PAGE_COL_VAR ?
-	    __col_var_last_recno(page) : __col_fix_last_recno(page);
+	    __col_var_last_recno(next_walk) : __col_fix_last_recno(next_walk);
 
 	return (__wt_page_release(session, next_walk, 0));
 }
diff --git a/src/btree/bt_page.c b/src/btree/bt_page.c
index 9fa0145bbdd..00ec8aa4494 100644
--- a/src/btree/bt_page.c
+++ b/src/btree/bt_page.c
@@ -10,7 +10,7 @@
 
 static void __inmem_col_fix(WT_SESSION_IMPL *, WT_PAGE *);
 static void __inmem_col_int(WT_SESSION_IMPL *, WT_PAGE *);
-static int  __inmem_col_var(WT_SESSION_IMPL *, WT_PAGE *, size_t *);
+static int  __inmem_col_var(WT_SESSION_IMPL *, WT_PAGE *, uint64_t, size_t *);
 static int  __inmem_row_int(WT_SESSION_IMPL *, WT_PAGE *, size_t *);
 static int  __inmem_row_leaf(WT_SESSION_IMPL *, WT_PAGE *);
 static int  __inmem_row_leaf_entries(
@@ -21,8 +21,8 @@ static int  __inmem_row_leaf_entries(
  *	Create or read a page into the cache.
  */
 int
-__wt_page_alloc(WT_SESSION_IMPL *session, uint8_t type,
-    uint64_t recno, uint32_t alloc_entries, bool alloc_refs, WT_PAGE **pagep)
+__wt_page_alloc(WT_SESSION_IMPL *session,
+    uint8_t type, uint32_t alloc_entries, bool alloc_refs, WT_PAGE **pagep)
 {
 	WT_CACHE *cache;
 	WT_DECL_RET;
@@ -67,13 +67,10 @@ __wt_page_alloc(WT_SESSION_IMPL *session, uint8_t type,
 
 	switch (type) {
 	case WT_PAGE_COL_FIX:
-		page->pg_fix_recno = recno;
 		page->pg_fix_entries = alloc_entries;
 		break;
 	case WT_PAGE_COL_INT:
 	case WT_PAGE_ROW_INT:
-		page->pg_intl_recno = recno;
-
 		/*
 		 * Internal pages have an array of references to objects so they
 		 * can split.  Allocate the array of references and optionally,
@@ -105,7 +102,6 @@ err:			if ((pindex = WT_INTL_INDEX_GET_SAFE(page)) != NULL) {
 		}
 		break;
 	case WT_PAGE_COL_VAR:
-		page->pg_var_recno = recno;
 		page->pg_var_d = (WT_COL *)((uint8_t *)page + sizeof(WT_PAGE));
 		page->pg_var_entries = alloc_entries;
 		break;
@@ -191,8 +187,7 @@ __wt_page_inmem(WT_SESSION_IMPL *session, WT_REF *ref,
 	}
 
 	/* Allocate and initialize a new WT_PAGE. */
-	WT_RET(__wt_page_alloc(
-	    session, dsk->type, dsk->recno, alloc_entries, true, &page));
+	WT_RET(__wt_page_alloc(session, dsk->type, alloc_entries, true, &page));
 	page->dsk = dsk;
 	F_SET_ATOMIC(page, flags);
 
@@ -211,7 +206,7 @@ __wt_page_inmem(WT_SESSION_IMPL *session, WT_REF *ref,
 		__inmem_col_int(session, page);
 		break;
 	case WT_PAGE_COL_VAR:
-		WT_ERR(__inmem_col_var(session, page, &size));
+		WT_ERR(__inmem_col_var(session, page, dsk->recno, &size));
 		break;
 	case WT_PAGE_ROW_INT:
 		WT_ERR(__inmem_row_int(session, page, &size));
@@ -292,7 +287,7 @@ __inmem_col_int(WT_SESSION_IMPL *session, WT_PAGE *page)
 
 		__wt_cell_unpack(cell, unpack);
 		ref->addr = cell;
-		ref->key.recno = unpack->v;
+		ref->ref_recno = unpack->v;
 	}
 }
 
@@ -329,7 +324,8 @@ __inmem_col_var_repeats(WT_SESSION_IMPL *session, WT_PAGE *page, uint32_t *np)
  *	column-store trees.
  */
 static int
-__inmem_col_var(WT_SESSION_IMPL *session, WT_PAGE *page, size_t *sizep)
+__inmem_col_var(
+    WT_SESSION_IMPL *session, WT_PAGE *page, uint64_t recno, size_t *sizep)
 {
 	WT_BTREE *btree;
 	WT_COL *cip;
@@ -337,13 +333,12 @@ __inmem_col_var(WT_SESSION_IMPL *session, WT_PAGE *page, size_t *sizep)
 	WT_CELL *cell;
 	WT_CELL_UNPACK *unpack, _unpack;
 	const WT_PAGE_HEADER *dsk;
-	uint64_t recno, rle;
+	uint64_t rle;
 	size_t bytes_allocated;
 	uint32_t i, indx, n, repeat_off;
 
 	btree = S2BT(session);
 	dsk = page->dsk;
-	recno = page->pg_var_recno;
 
 	repeats = NULL;
 	repeat_off = 0;
diff --git a/src/btree/bt_read.c b/src/btree/bt_read.c
index 5cf6a9bf2bc..5fc3c4fddee 100644
--- a/src/btree/bt_read.c
+++ b/src/btree/bt_read.c
@@ -377,9 +377,7 @@ __page_read(WT_SESSION_IMPL *session, WT_REF *ref)
 	if (addr == NULL) {
 		WT_ASSERT(session, previous_state == WT_REF_DELETED);
 
-		WT_ERR(__wt_btree_new_leaf_page(session,
-		    btree->type == BTREE_ROW ? WT_RECNO_OOB : ref->key.recno,
-		    &page));
+		WT_ERR(__wt_btree_new_leaf_page(session, &page));
 		ref->page = page;
 		goto done;
 	}
diff --git a/src/btree/bt_rebalance.c b/src/btree/bt_rebalance.c
index d94eb2ddd80..de54e8433a8 100644
--- a/src/btree/bt_rebalance.c
+++ b/src/btree/bt_rebalance.c
@@ -90,7 +90,7 @@ __rebalance_leaf_append(WT_SESSION_IMPL *session,
 	if (recno == WT_RECNO_OOB)
 		WT_RET(__wt_row_ikey(session, 0, key, key_len, copy));
 	else
-		copy->key.recno = recno;
+		copy->ref_recno = recno;
 
 	copy->page_del = NULL;
 	return (0);
@@ -147,8 +147,7 @@ __rebalance_internal(WT_SESSION_IMPL *session, WT_REBALANCE_STUFF *rs)
 	leaf_next = (uint32_t)rs->leaf_next;
 
 	/* Allocate a row-store root (internal) page and fill it in. */
-	WT_RET(__wt_page_alloc(session, rs->type,
-	    rs->type == WT_PAGE_COL_INT ? 1 : 0, leaf_next, false, &page));
+	WT_RET(__wt_page_alloc(session, rs->type, leaf_next, false, &page));
 	page->pg_intl_parent_ref = &btree->root;
 	WT_ERR(__wt_page_modify_init(session, page));
 	__wt_page_modify_set(session, page);
diff --git a/src/btree/bt_ret.c b/src/btree/bt_ret.c
index 8ef21bffa41..8ef2db67e7b 100644
--- a/src/btree/bt_ret.c
+++ b/src/btree/bt_ret.c
@@ -46,7 +46,7 @@ __wt_kv_return(WT_SESSION_IMPL *session, WT_CURSOR_BTREE *cbt, WT_UPDATE *upd)
 		}
 
 		/* Take the value from the original page. */
-		v = __bit_getv_recno(page, cursor->recno, btree->bitcnt);
+		v = __bit_getv_recno(cbt->ref, cursor->recno, btree->bitcnt);
 		return (__wt_buf_set(session, &cursor->value, &v, 1));
 	case WT_PAGE_COL_VAR:
 		/*
diff --git a/src/btree/bt_slvg.c b/src/btree/bt_slvg.c
index 55b064086fb..15c2ba52488 100644
--- a/src/btree/bt_slvg.c
+++ b/src/btree/bt_slvg.c
@@ -117,7 +117,7 @@ static int  __slvg_cleanup(WT_SESSION_IMPL *, WT_STUFF *);
 static int  __slvg_col_build_internal(WT_SESSION_IMPL *, uint32_t, WT_STUFF *);
 static int  __slvg_col_build_leaf(WT_SESSION_IMPL *, WT_TRACK *, WT_REF *);
 static int  __slvg_col_ovfl(
-		WT_SESSION_IMPL *, WT_TRACK *, WT_PAGE *, uint64_t, uint64_t);
+		WT_SESSION_IMPL *, WT_TRACK *, WT_REF *, uint64_t, uint64_t);
 static int  __slvg_col_range(WT_SESSION_IMPL *, WT_STUFF *);
 static int  __slvg_col_range_missing(WT_SESSION_IMPL *, WT_STUFF *);
 static int  __slvg_col_range_overlap(
@@ -1171,7 +1171,7 @@ __slvg_col_build_internal(
 
 	/* Allocate a column-store root (internal) page and fill it in. */
 	WT_RET(__wt_page_alloc(
-	    session, WT_PAGE_COL_INT, 1, leaf_cnt, true, &page));
+	    session, WT_PAGE_COL_INT, leaf_cnt, true, &page));
 	WT_ERR(__slvg_modify_init(session, page));
 
 	pindex = WT_INTL_INDEX_GET_SAFE(page);
@@ -1192,7 +1192,7 @@ __slvg_col_build_internal(
 		ref->addr = addr;
 		addr = NULL;
 
-		ref->key.recno = trk->col_start;
+		ref->ref_recno = trk->col_start;
 		ref->state = WT_REF_DISK;
 
 		/*
@@ -1255,7 +1255,7 @@ __slvg_col_build_leaf(WT_SESSION_IMPL *session, WT_TRACK *trk, WT_REF *ref)
 	 * Calculate the number of K/V entries we are going to skip, and
 	 * the total number of K/V entries we'll take from this page.
 	 */
-	cookie->skip = skip = trk->col_start - page->pg_var_recno;
+	cookie->skip = skip = trk->col_start - ref->ref_recno;
 	cookie->take = take = (trk->col_stop - trk->col_start) + 1;
 
 	WT_ERR(__wt_verbose(session, WT_VERB_SALVAGE,
@@ -1267,7 +1267,7 @@ __slvg_col_build_leaf(WT_SESSION_IMPL *session, WT_TRACK *trk, WT_REF *ref)
 
 	/* Set the referenced flag on overflow pages we're using. */
 	if (page->type == WT_PAGE_COL_VAR && trk->trk_ovfl_cnt != 0)
-		WT_ERR(__slvg_col_ovfl(session, trk, page, skip, take));
+		WT_ERR(__slvg_col_ovfl(session, trk, ref, skip, take));
 
 	/*
 	 * If we're missing some part of the range, the real start range is in
@@ -1275,9 +1275,9 @@ __slvg_col_build_leaf(WT_SESSION_IMPL *session, WT_TRACK *trk, WT_REF *ref)
 	 * reference as well as the page itself.
 	 */
 	if (trk->col_missing == 0)
-		page->pg_var_recno = trk->col_start;
+		ref->ref_recno = trk->col_start;
 	else {
-		page->pg_var_recno = trk->col_missing;
+		ref->ref_recno = trk->col_missing;
 		cookie->missing = trk->col_start - trk->col_missing;
 
 		WT_ERR(__wt_verbose(session, WT_VERB_SALVAGE,
@@ -1286,7 +1286,6 @@ __slvg_col_build_leaf(WT_SESSION_IMPL *session, WT_TRACK *trk, WT_REF *ref)
 		    session, trk->trk_addr, trk->trk_addr_size, trk->ss->tmp1),
 		    cookie->missing));
 	}
-	ref->key.recno = page->pg_var_recno;
 
 	/*
 	 * We can't discard the original blocks associated with this page now.
@@ -1351,12 +1350,13 @@ __slvg_col_ovfl_single(
  */
 static int
 __slvg_col_ovfl(WT_SESSION_IMPL *session,
-    WT_TRACK *trk, WT_PAGE *page, uint64_t skip, uint64_t take)
+    WT_TRACK *trk, WT_REF *ref, uint64_t skip, uint64_t take)
 {
 	WT_CELL_UNPACK unpack;
 	WT_CELL *cell;
 	WT_COL *cip;
 	WT_DECL_RET;
+	WT_PAGE *page;
 	uint64_t recno, start, stop;
 	uint32_t i;
 
@@ -1364,7 +1364,8 @@ __slvg_col_ovfl(WT_SESSION_IMPL *session,
 	 * Merging a variable-length column-store page, and we took some number
 	 * of records, figure out which (if any) overflow records we used.
 	 */
-	recno = page->pg_var_recno;
+	recno = ref->ref_recno;
+	page = ref->page;
 	start = recno + skip;
 	stop = (recno + skip + take) - 1;
 
@@ -1828,7 +1829,7 @@ __slvg_row_build_internal(
 
 	/* Allocate a row-store root (internal) page and fill it in. */
 	WT_RET(__wt_page_alloc(
-	    session, WT_PAGE_ROW_INT, WT_RECNO_OOB, leaf_cnt, true, &page));
+	    session, WT_PAGE_ROW_INT, leaf_cnt, true, &page));
 	WT_ERR(__slvg_modify_init(session, page));
 
 	pindex = WT_INTL_INDEX_GET_SAFE(page);
diff --git a/src/btree/bt_split.c b/src/btree/bt_split.c
index 81f8bf67c41..335a99b9b8b 100644
--- a/src/btree/bt_split.c
+++ b/src/btree/bt_split.c
@@ -207,8 +207,8 @@ __split_verify_intl_key_order(WT_SESSION_IMPL *session, WT_PAGE *page)
 		WT_INTL_FOREACH_BEGIN(session, page, ref) {
 			WT_ASSERT(session, ref->home == page);
 
-			WT_ASSERT(session, ref->key.recno > recno);
-			recno = ref->key.recno;
+			WT_ASSERT(session, ref->ref_recno > recno);
+			recno = ref->ref_recno;
 		} WT_INTL_FOREACH_END;
 		break;
 	case WT_PAGE_ROW_INT:
@@ -335,7 +335,7 @@ __split_ref_move(WT_SESSION_IMPL *session, WT_PAGE *from_home,
 		if ((ikey = __wt_ref_key_instantiated(ref)) == NULL) {
 			__wt_ref_key(from_home, ref, &key, &size);
 			WT_RET(__wt_row_ikey(session, 0, key, size, ref));
-			ikey = ref->key.ikey;
+			ikey = ref->ref_ikey;
 		} else {
 			WT_RET(
 			    __split_ovfl_key_cleanup(session, from_home, ref));
@@ -529,7 +529,7 @@ __split_root(WT_SESSION_IMPL *session, WT_PAGE *root)
 	WT_REF **child_refp, *ref, **root_refp;
 	WT_SPLIT_ERROR_PHASE complete;
 	size_t child_incr, root_decr, root_incr, size;
-	uint64_t recno, split_gen;
+	uint64_t split_gen;
 	uint32_t children, chunk, i, j, remain;
 	uint32_t slots;
 	void *p;
@@ -593,10 +593,8 @@ __split_root(WT_SESSION_IMPL *session, WT_PAGE *root)
 	    alloc_refp = alloc_index->index, i = 0; i < children; ++i) {
 		slots = i == children - 1 ? remain : chunk;
 
-		recno = root->type == WT_PAGE_COL_INT ?
-		    (*root_refp)->key.recno : WT_RECNO_OOB;
 		WT_ERR(__wt_page_alloc(
-		    session, root->type, recno, slots, false, &child));
+		    session, root->type, slots, false, &child));
 
 		/*
 		 * Initialize the page's child reference; we need a copy of the
@@ -611,7 +609,7 @@ __split_root(WT_SESSION_IMPL *session, WT_PAGE *root)
 			WT_ERR(__wt_row_ikey(session, 0, p, size, ref));
 			root_incr += sizeof(WT_IKEY) + size;
 		} else
-			ref->key.recno = recno;
+			ref->ref_recno = (*root_refp)->ref_recno;
 		ref->state = WT_REF_MEM;
 
 		/* Initialize the child page. */
@@ -1013,7 +1011,7 @@ __split_internal(WT_SESSION_IMPL *session, WT_PAGE *parent, WT_PAGE *page)
 	WT_REF **child_refp, *page_ref, **page_refp, *ref;
 	WT_SPLIT_ERROR_PHASE complete;
 	size_t child_incr, page_decr, page_incr, parent_incr, size;
-	uint64_t recno, split_gen;
+	uint64_t split_gen;
 	uint32_t children, chunk, i, j, remain;
 	uint32_t slots;
 	void *p;
@@ -1098,10 +1096,8 @@ __split_internal(WT_SESSION_IMPL *session, WT_PAGE *parent, WT_PAGE *page)
 	for (alloc_refp = alloc_index->index + 1, i = 1; i < children; ++i) {
 		slots = i == children - 1 ? remain : chunk;
 
-		recno = page->type == WT_PAGE_COL_INT ?
-		    (*page_refp)->key.recno : WT_RECNO_OOB;
 		WT_ERR(__wt_page_alloc(
-		    session, page->type, recno, slots, false, &child));
+		    session, page->type, slots, false, &child));
 
 		/*
 		 * Initialize the page's child reference; we need a copy of the
@@ -1116,7 +1112,7 @@ __split_internal(WT_SESSION_IMPL *session, WT_PAGE *parent, WT_PAGE *page)
 			WT_ERR(__wt_row_ikey(session, 0, p, size, ref));
 			parent_incr += sizeof(WT_IKEY) + size;
 		} else
-			ref->key.recno = recno;
+			ref->ref_recno = (*page_refp)->ref_recno;
 		ref->state = WT_REF_MEM;
 
 		/* Initialize the child page. */
@@ -1662,7 +1658,7 @@ __wt_multi_to_ref(WT_SESSION_IMPL *session,
 		incr += sizeof(WT_IKEY) + ikey->size;
 		break;
 	default:
-		ref->key.recno = multi->key.recno;
+		ref->ref_recno = multi->key.recno;
 		break;
 	}
 
@@ -1772,17 +1768,12 @@ __split_insert(WT_SESSION_IMPL *session, WT_REF *ref)
 		parent_incr += sizeof(WT_IKEY) + key->size;
 		__wt_scr_free(session, &key);
 	} else
-		child->key.recno = ref->key.recno;
+		child->ref_recno = ref->ref_recno;
 
 	/*
 	 * The second page in the split is a new WT_REF/page pair.
 	 */
-	if (type == WT_PAGE_ROW_LEAF)
-		WT_ERR(__wt_page_alloc(session,
-		    type, WT_RECNO_OOB, 0, false, &right));
-	else
-		WT_ERR(__wt_page_alloc(session,
-		    type, WT_INSERT_RECNO(moved_ins), 0, false, &right));
+	WT_ERR(__wt_page_alloc(session, type, 0, false, &right));
 
 	/*
 	 * The new page is dirty by definition, plus column-store splits update
@@ -1813,7 +1804,7 @@ __split_insert(WT_SESSION_IMPL *session, WT_REF *ref)
 		    child));
 		parent_incr += sizeof(WT_IKEY) + WT_INSERT_KEY_SIZE(moved_ins);
 	} else
-		child->key.recno = WT_INSERT_RECNO(moved_ins);
+		child->ref_recno = WT_INSERT_RECNO(moved_ins);
 
 	/*
 	 * Allocation operations completed, we're going to split.
@@ -1823,7 +1814,7 @@ __split_insert(WT_SESSION_IMPL *session, WT_REF *ref)
 	if (type != WT_PAGE_ROW_LEAF) {
 		WT_ASSERT(session,
 		    page->modify->mod_split_recno == WT_RECNO_OOB);
-		page->modify->mod_split_recno = child->key.recno;
+		page->modify->mod_split_recno = child->ref_recno;
 	}
 
 	/*
@@ -1998,12 +1989,12 @@ err:	if (split_ref[0] != NULL) {
 		ref->addr = split_ref[0]->addr;
 
 		if (type == WT_PAGE_ROW_LEAF)
-			__wt_free(session, split_ref[0]->key.ikey);
+			__wt_free(session, split_ref[0]->ref_ikey);
 		__wt_free(session, split_ref[0]);
 	}
 	if (split_ref[1] != NULL) {
 		if (type == WT_PAGE_ROW_LEAF)
-			__wt_free(session, split_ref[1]->key.ikey);
+			__wt_free(session, split_ref[1]->ref_ikey);
 		__wt_free(session, split_ref[1]);
 	}
 	if (right != NULL) {
diff --git a/src/btree/bt_vrfy.c b/src/btree/bt_vrfy.c
index 83dc7924312..531a0dc125a 100644
--- a/src/btree/bt_vrfy.c
+++ b/src/btree/bt_vrfy.c
@@ -355,7 +355,7 @@ __verify_tree(WT_SESSION_IMPL *session, WT_REF *ref, WT_VSTUFF *vs)
 	if (vs->dump_blocks)
 		WT_RET(__wt_debug_disk(session, page->dsk, NULL));
 	if (vs->dump_pages)
-		WT_RET(__wt_debug_page(session, page, NULL));
+		WT_RET(__wt_debug_page(session, ref, NULL));
 #endif
 
 	/*
@@ -364,13 +364,11 @@ __verify_tree(WT_SESSION_IMPL *session, WT_REF *ref, WT_VSTUFF *vs)
 	 */
 	switch (page->type) {
 	case WT_PAGE_COL_FIX:
-		recno = page->pg_fix_recno;
-		goto recno_chk;
 	case WT_PAGE_COL_INT:
-		recno = page->pg_intl_recno;
+		recno = ref->ref_recno;
 		goto recno_chk;
 	case WT_PAGE_COL_VAR:
-		recno = page->pg_var_recno;
+		recno = ref->ref_recno;
 recno_chk:	if (recno != vs->record_total + 1)
 			WT_RET_MSG(session, WT_ERROR,
 			    "page at %s has a starting record of %" PRIu64
@@ -485,7 +483,7 @@ celltype_err:			WT_RET_MSG(session, WT_ERROR,
 			 * reviewed to this point.
 			 */
 			++entry;
-			if (child_ref->key.recno != vs->record_total + 1) {
+			if (child_ref->ref_recno != vs->record_total + 1) {
 				WT_RET_MSG(session, WT_ERROR,
 				    "the starting record number in entry %"
 				    PRIu32 " of the column internal page at "
@@ -494,7 +492,7 @@ celltype_err:			WT_RET_MSG(session, WT_ERROR,
 				    entry,
 				    __wt_page_addr_string(
 				    session, child_ref, vs->tmp1),
-				    child_ref->key.recno,
+				    child_ref->ref_recno,
 				    vs->record_total + 1);
 			}
 
diff --git a/src/btree/col_modify.c b/src/btree/col_modify.c
index fd60b12538a..403a9d87a8e 100644
--- a/src/btree/col_modify.c
+++ b/src/btree/col_modify.c
@@ -55,7 +55,8 @@ __wt_col_modify(WT_SESSION_IMPL *session, WT_CURSOR_BTREE *cbt,
 		 */
 		if (recno == WT_RECNO_OOB ||
 		    recno > (btree->type == BTREE_COL_VAR ?
-		    __col_var_last_recno(page) : __col_fix_last_recno(page)))
+		    __col_var_last_recno(cbt->ref) :
+		    __col_fix_last_recno(cbt->ref)))
 			append = true;
 	}
 
diff --git a/src/btree/col_srch.c b/src/btree/col_srch.c
index 4730267a545..6c96181d3bf 100644
--- a/src/btree/col_srch.c
+++ b/src/btree/col_srch.c
@@ -30,7 +30,7 @@ __check_leaf_key_range(WT_SESSION_IMPL *session,
 	 * Check if the search key is smaller than the parent's starting key for
 	 * this page.
 	 */
-	if (recno < leaf->key.recno) {
+	if (recno < leaf->ref_recno) {
 		cbt->compare = 1;		/* page keys > search key */
 		return (0);
 	}
@@ -48,7 +48,7 @@ __check_leaf_key_range(WT_SESSION_IMPL *session,
 	WT_INTL_INDEX_GET(session, leaf->home, pindex);
 	indx = leaf->pindex_hint;
 	if (indx + 1 < pindex->entries && pindex->index[indx] == leaf)
-		if (recno >= pindex->index[indx + 1]->key.recno) {
+		if (recno >= pindex->index[indx + 1]->ref_recno) {
 			cbt->compare = -1;	/* page keys < search key */
 			return (0);
 		}
@@ -133,14 +133,12 @@ restart:	/*
 		if (page->type != WT_PAGE_COL_INT)
 			break;
 
-		WT_ASSERT(session, current->key.recno == page->pg_intl_recno);
-
 		WT_INTL_INDEX_GET(session, page, pindex);
 		base = pindex->entries;
 		descent = pindex->index[base - 1];
 
 		/* Fast path appends. */
-		if (recno >= descent->key.recno) {
+		if (recno >= descent->ref_recno) {
 			/*
 			 * If on the last slot (the key is larger than any key
 			 * on the page), check for an internal page split race.
@@ -158,9 +156,9 @@ restart:	/*
 			indx = base + (limit >> 1);
 			descent = pindex->index[indx];
 
-			if (recno == descent->key.recno)
+			if (recno == descent->ref_recno)
 				break;
-			if (recno < descent->key.recno)
+			if (recno < descent->ref_recno)
 				continue;
 			base = indx + 1;
 			--limit;
@@ -172,7 +170,7 @@ descend:	/*
 		 * (last + 1) index.  The slot for descent is the one before
 		 * base.
 		 */
-		if (recno != descent->key.recno) {
+		if (recno != descent->ref_recno) {
 			/*
 			 * We don't have to correct for base == 0 because the
 			 * only way for base to be 0 is if recno is the page's
@@ -237,13 +235,13 @@ leaf_only:
 	 * do in that case, the record may be appended to the page.
 	 */
 	if (page->type == WT_PAGE_COL_FIX) {
-		if (recno < page->pg_fix_recno) {
-			cbt->recno = page->pg_fix_recno;
+		if (recno < current->ref_recno) {
+			cbt->recno = current->ref_recno;
 			cbt->compare = 1;
 			return (0);
 		}
-		if (recno >= page->pg_fix_recno + page->pg_fix_entries) {
-			cbt->recno = page->pg_fix_recno + page->pg_fix_entries;
+		if (recno >= current->ref_recno + page->pg_fix_entries) {
+			cbt->recno = current->ref_recno + page->pg_fix_entries;
 			goto past_end;
 		} else {
 			cbt->recno = recno;
@@ -251,14 +249,14 @@ leaf_only:
 			ins_head = WT_COL_UPDATE_SINGLE(page);
 		}
 	} else {
-		if (recno < page->pg_var_recno) {
-			cbt->recno = page->pg_var_recno;
+		if (recno < current->ref_recno) {
+			cbt->recno = current->ref_recno;
 			cbt->slot = 0;
 			cbt->compare = 1;
 			return (0);
 		}
-		if ((cip = __col_var_search(page, recno, NULL)) == NULL) {
-			cbt->recno = __col_var_last_recno(page);
+		if ((cip = __col_var_search(current, recno, NULL)) == NULL) {
+			cbt->recno = __col_var_last_recno(current);
 			cbt->slot = page->pg_var_entries == 0 ?
 			    0 : page->pg_var_entries - 1;
 			goto past_end;
diff --git a/src/btree/row_key.c b/src/btree/row_key.c
index 9fff092d079..83fd2dad9e4 100644
--- a/src/btree/row_key.c
+++ b/src/btree/row_key.c
@@ -517,7 +517,7 @@ __wt_row_ikey(WT_SESSION_IMPL *session,
 	{
 	uintptr_t oldv;
 
-	oldv = (uintptr_t)ref->key.ikey;
+	oldv = (uintptr_t)ref->ref_ikey;
 	WT_DIAGNOSTIC_YIELD;
 
 	/*
@@ -527,10 +527,10 @@ __wt_row_ikey(WT_SESSION_IMPL *session,
 	WT_ASSERT(session, oldv == 0 || (oldv & WT_IK_FLAG) != 0);
 	WT_ASSERT(session, ref->state != WT_REF_SPLIT);
 	WT_ASSERT(session,
-	    __wt_atomic_cas_ptr(&ref->key.ikey, (WT_IKEY *)oldv, ikey));
+	    __wt_atomic_cas_ptr(&ref->ref_ikey, (WT_IKEY *)oldv, ikey));
 	}
 #else
-	ref->key.ikey = ikey;
+	ref->ref_ikey = ikey;
 #endif
 	return (0);
 }
diff --git a/src/include/bitstring.i b/src/include/bitstring.i
index 308fdeb9668..08746beb9b9 100644
--- a/src/include/bitstring.i
+++ b/src/include/bitstring.i
@@ -261,10 +261,10 @@ __bit_getv(uint8_t *bitf, uint64_t entry, uint8_t width)
  *	Return a record number's bit-field value.
  */
 static inline uint8_t
-__bit_getv_recno(WT_PAGE *page, uint64_t recno, uint8_t width)
+__bit_getv_recno(WT_REF *ref, uint64_t recno, uint8_t width)
 {
 	return (__bit_getv(
-	    page->pg_fix_bitf, recno - page->pg_fix_recno, width));
+	    ref->page->pg_fix_bitf, recno - ref->ref_recno, width));
 }
 
 /*
diff --git a/src/include/btmem.h b/src/include/btmem.h
index 7cdf2bef43a..437b409d0da 100644
--- a/src/include/btmem.h
+++ b/src/include/btmem.h
@@ -433,7 +433,6 @@ struct __wt_page {
 		 * doesn't read it multiple times).
 		 */
 		struct {
-			uint64_t recno;		/* Starting recno */
 			WT_REF	*parent_ref;	/* Parent reference */
 
 			struct __wt_page_index {
@@ -442,8 +441,7 @@ struct __wt_page {
 				WT_REF	**index;
 			} * volatile __index;	/* Collated children */
 		} intl;
-#undef	pg_intl_recno
-#define	pg_intl_recno			u.intl.recno
+#undef	pg_intl_parent_ref
 #define	pg_intl_parent_ref		u.intl.parent_ref
 
 	/*
@@ -509,13 +507,9 @@ struct __wt_page {
 
 		/* Fixed-length column-store leaf page. */
 		struct {
-			uint64_t recno;		/* Starting recno */
-
 			uint8_t	*bitf;		/* Values */
 			uint32_t entries;	/* Entries */
 		} col_fix;
-#undef	pg_fix_recno
-#define	pg_fix_recno	u.col_fix.recno
 #undef	pg_fix_bitf
 #define	pg_fix_bitf	u.col_fix.bitf
 #undef	pg_fix_entries
@@ -523,8 +517,6 @@ struct __wt_page {
 
 		/* Variable-length column-store leaf page. */
 		struct {
-			uint64_t recno;		/* Starting recno */
-
 			WT_COL *d;		/* Values */
 
 			/*
@@ -537,8 +529,6 @@ struct __wt_page {
 
 			uint32_t    entries;	/* Entries */
 		} col_var;
-#undef	pg_var_recno
-#define	pg_var_recno	u.col_var.recno
 #undef	pg_var_d
 #define	pg_var_d	u.col_var.d
 #undef	pg_var_repeats
@@ -732,6 +722,10 @@ struct __wt_ref {
 		uint64_t recno;		/* Column-store: starting recno */
 		void	*ikey;		/* Row-store: key */
 	} key;
+#undef	ref_recno
+#define	ref_recno	key.recno
+#undef	ref_ikey
+#define	ref_ikey	key.ikey
 
 	WT_PAGE_DELETED	*page_del;	/* Deleted on-disk page information */
 };
diff --git a/src/include/btree.i b/src/include/btree.i
index 6df7f87073f..4c8166ca6a6 100644
--- a/src/include/btree.i
+++ b/src/include/btree.i
@@ -511,8 +511,8 @@ __wt_ref_key(WT_PAGE *page, WT_REF *ref, void *keyp, size_t *sizep)
 
 	/*
 	 * An internal page key is in one of two places: if we instantiated the
-	 * key (for example, when reading the page), WT_REF.key.ikey references
-	 * a WT_IKEY structure, otherwise WT_REF.key.ikey references an on-page
+	 * key (for example, when reading the page), WT_REF.ref_ikey references
+	 * a WT_IKEY structure, otherwise WT_REF.ref_ikey references an on-page
 	 * key offset/length pair.
 	 *
 	 * Now the magic: allocated memory must be aligned to store any standard
@@ -536,14 +536,14 @@ __wt_ref_key(WT_PAGE *page, WT_REF *ref, void *keyp, size_t *sizep)
 #define	WT_IK_DECODE_KEY_LEN(v)		((v) >> 32)
 #define	WT_IK_ENCODE_KEY_OFFSET(v)	((uintptr_t)(v) << 1)
 #define	WT_IK_DECODE_KEY_OFFSET(v)	(((v) & 0xFFFFFFFF) >> 1)
-	v = (uintptr_t)ref->key.ikey;
+	v = (uintptr_t)ref->ref_ikey;
 	if (v & WT_IK_FLAG) {
 		*(void **)keyp =
 		    WT_PAGE_REF_OFFSET(page, WT_IK_DECODE_KEY_OFFSET(v));
 		*sizep = WT_IK_DECODE_KEY_LEN(v);
 	} else {
-		*(void **)keyp = WT_IKEY_DATA(ref->key.ikey);
-		*sizep = ((WT_IKEY *)ref->key.ikey)->size;
+		*(void **)keyp = WT_IKEY_DATA(ref->ref_ikey);
+		*sizep = ((WT_IKEY *)ref->ref_ikey)->size;
 	}
 }
 
@@ -562,7 +562,7 @@ __wt_ref_key_onpage_set(WT_PAGE *page, WT_REF *ref, WT_CELL_UNPACK *unpack)
 	v = WT_IK_ENCODE_KEY_LEN(unpack->size) |
 	    WT_IK_ENCODE_KEY_OFFSET(WT_PAGE_DISK_OFFSET(page, unpack->data)) |
 	    WT_IK_FLAG;
-	ref->key.ikey = (void *)v;
+	ref->ref_ikey = (void *)v;
 }
 
 /*
@@ -577,8 +577,8 @@ __wt_ref_key_instantiated(WT_REF *ref)
 	/*
 	 * See the comment in __wt_ref_key for an explanation of the magic.
 	 */
-	v = (uintptr_t)ref->key.ikey;
-	return (v & WT_IK_FLAG ? NULL : ref->key.ikey);
+	v = (uintptr_t)ref->ref_ikey;
+	return (v & WT_IK_FLAG ? NULL : ref->ref_ikey);
 }
 
 /*
@@ -591,10 +591,10 @@ __wt_ref_key_clear(WT_REF *ref)
 	/*
 	 * The key union has 2 8B fields; this is equivalent to:
 	 *
-	 *	ref->key.recno = WT_RECNO_OOB;
-	 *	ref->key.ikey = NULL;
+	 *	ref->ref_recno = WT_RECNO_OOB;
+	 *	ref->ref_ikey = NULL;
 	 */
-	ref->key.recno = 0;
+	ref->ref_recno = 0;
 }
 
 /*
diff --git a/src/include/column.i b/src/include/column.i
index d64e68420a5..d15f874b281 100644
--- a/src/include/column.i
+++ b/src/include/column.i
@@ -209,9 +209,12 @@ __col_insert_search(WT_INSERT_HEAD *ins_head,
  *	Return the last record number for a variable-length column-store page.
  */
 static inline uint64_t
-__col_var_last_recno(WT_PAGE *page)
+__col_var_last_recno(WT_REF *ref)
 {
 	WT_COL_RLE *repeat;
+	WT_PAGE *page;
+
+	page = ref->page;
 
 	/*
 	 * If there's an append list, there may be more records on the page.
@@ -220,7 +223,7 @@ __col_var_last_recno(WT_PAGE *page)
 	 */
 	if (page->pg_var_nrepeats == 0)
 		return (page->pg_var_entries == 0 ? 0 :
-		    page->pg_var_recno + (page->pg_var_entries - 1));
+		    ref->ref_recno + (page->pg_var_entries - 1));
 
 	repeat = &page->pg_var_repeats[page->pg_var_nrepeats - 1];
 	return ((repeat->recno + repeat->rle) - 1 +
@@ -232,15 +235,19 @@ __col_var_last_recno(WT_PAGE *page)
  *	Return the last record number for a fixed-length column-store page.
  */
 static inline uint64_t
-__col_fix_last_recno(WT_PAGE *page)
+__col_fix_last_recno(WT_REF *ref)
 {
+	WT_PAGE *page;
+
+	page = ref->page;
+
 	/*
 	 * If there's an append list, there may be more records on the page.
 	 * This function ignores those records, our callers must handle that
 	 * explicitly, if they care.
 	 */
-	return (page->pg_fix_entries == 0 ? 0 :
-	    page->pg_fix_recno + (page->pg_fix_entries - 1));
+	return (page->pg_fix_entries == 0 ?
+	    0 : ref->ref_recno + (page->pg_fix_entries - 1));
 }
 
 /*
@@ -248,12 +255,15 @@ __col_fix_last_recno(WT_PAGE *page)
  *	Search a variable-length column-store page for a record.
  */
 static inline WT_COL *
-__col_var_search(WT_PAGE *page, uint64_t recno, uint64_t *start_recnop)
+__col_var_search(WT_REF *ref, uint64_t recno, uint64_t *start_recnop)
 {
 	WT_COL_RLE *repeat;
+	WT_PAGE *page;
 	uint64_t start_recno;
 	uint32_t base, indx, limit, start_indx;
 
+	page = ref->page;
+
 	/*
 	 * Find the matching slot.
 	 *
@@ -285,7 +295,7 @@ __col_var_search(WT_PAGE *page, uint64_t recno, uint64_t *start_recnop)
 	 */
 	if (base == 0) {
 		start_indx = 0;
-		start_recno = page->pg_var_recno;
+		start_recno = ref->ref_recno;
 	} else {
 		repeat = page->pg_var_repeats + (base - 1);
 		start_indx = repeat->indx + 1;
diff --git a/src/include/extern.h b/src/include/extern.h
index e9333b669b8..0353ec60b30 100644
--- a/src/include/extern.h
+++ b/src/include/extern.h
@@ -118,9 +118,9 @@ extern int __wt_debug_offset_blind( WT_SESSION_IMPL *session, wt_off_t offset, c
 extern int __wt_debug_offset(WT_SESSION_IMPL *session, wt_off_t offset, uint32_t size, uint32_t cksum, const char *ofile);
 extern int __wt_debug_disk( WT_SESSION_IMPL *session, const WT_PAGE_HEADER *dsk, const char *ofile);
 extern int __wt_debug_tree_shape( WT_SESSION_IMPL *session, WT_PAGE *page, const char *ofile);
-extern int __wt_debug_tree_all( WT_SESSION_IMPL *session, WT_BTREE *btree, WT_PAGE *page, const char *ofile);
-extern int __wt_debug_tree( WT_SESSION_IMPL *session, WT_BTREE *btree, WT_PAGE *page, const char *ofile);
-extern int __wt_debug_page(WT_SESSION_IMPL *session, WT_PAGE *page, const char *ofile);
+extern int __wt_debug_tree_all( WT_SESSION_IMPL *session, WT_BTREE *btree, WT_REF *ref, const char *ofile);
+extern int __wt_debug_tree( WT_SESSION_IMPL *session, WT_BTREE *btree, WT_REF *ref, const char *ofile);
+extern int __wt_debug_page(WT_SESSION_IMPL *session, WT_REF *ref, const char *ofile);
 extern int __wt_delete_page(WT_SESSION_IMPL *session, WT_REF *ref, bool *skipp);
 extern void __wt_delete_page_rollback(WT_SESSION_IMPL *session, WT_REF *ref);
 extern bool __wt_delete_page_skip(WT_SESSION_IMPL *session, WT_REF *ref, bool visible_all);
@@ -134,7 +134,7 @@ extern int __wt_btree_open(WT_SESSION_IMPL *session, const char *op_cfg[]);
 extern int __wt_btree_close(WT_SESSION_IMPL *session);
 extern void __wt_root_ref_init(WT_REF *root_ref, WT_PAGE *root, bool is_recno);
 extern int __wt_btree_tree_open( WT_SESSION_IMPL *session, const uint8_t *addr, size_t addr_size);
-extern int __wt_btree_new_leaf_page( WT_SESSION_IMPL *session, uint64_t recno, WT_PAGE **pagep);
+extern int __wt_btree_new_leaf_page(WT_SESSION_IMPL *session, WT_PAGE **pagep);
 extern void __wt_btree_evictable(WT_SESSION_IMPL *session, bool on);
 extern int __wt_btree_huffman_open(WT_SESSION_IMPL *session);
 extern void __wt_btree_huffman_close(WT_SESSION_IMPL *session);
@@ -148,7 +148,7 @@ extern const char *__wt_buf_set_printable( WT_SESSION_IMPL *session, const void
 extern int __wt_ovfl_read(WT_SESSION_IMPL *session, WT_PAGE *page, WT_CELL_UNPACK *unpack, WT_ITEM *store);
 extern int __wt_ovfl_cache(WT_SESSION_IMPL *session, WT_PAGE *page, void *cookie, WT_CELL_UNPACK *vpack);
 extern int __wt_ovfl_discard(WT_SESSION_IMPL *session, WT_CELL *cell);
-extern int __wt_page_alloc(WT_SESSION_IMPL *session, uint8_t type, uint64_t recno, uint32_t alloc_entries, bool alloc_refs, WT_PAGE **pagep);
+extern int __wt_page_alloc(WT_SESSION_IMPL *session, uint8_t type, uint32_t alloc_entries, bool alloc_refs, WT_PAGE **pagep);
 extern int __wt_page_inmem(WT_SESSION_IMPL *session, WT_REF *ref, const void *image, size_t memsize, uint32_t flags, WT_PAGE **pagep);
 extern int __wt_las_remove_block(WT_SESSION_IMPL *session, WT_CURSOR *cursor, uint32_t btree_id, const uint8_t *addr, size_t addr_size);
 extern int
diff --git a/src/reconcile/rec_write.c b/src/reconcile/rec_write.c
index 873482df131..1358aafbf8d 100644
--- a/src/reconcile/rec_write.c
+++ b/src/reconcile/rec_write.c
@@ -299,13 +299,13 @@ static int  __rec_cell_build_ovfl(WT_SESSION_IMPL *,
 		WT_RECONCILE *, WT_KV *, uint8_t, uint64_t);
 static int  __rec_cell_build_val(WT_SESSION_IMPL *,
 		WT_RECONCILE *, const void *, size_t, uint64_t);
-static int  __rec_col_fix(WT_SESSION_IMPL *, WT_RECONCILE *, WT_PAGE *);
+static int  __rec_col_fix(WT_SESSION_IMPL *, WT_RECONCILE *, WT_REF *);
 static int  __rec_col_fix_slvg(WT_SESSION_IMPL *,
-		WT_RECONCILE *, WT_PAGE *, WT_SALVAGE_COOKIE *);
-static int  __rec_col_int(WT_SESSION_IMPL *, WT_RECONCILE *, WT_PAGE *);
+		WT_RECONCILE *, WT_REF *, WT_SALVAGE_COOKIE *);
+static int  __rec_col_int(WT_SESSION_IMPL *, WT_RECONCILE *, WT_REF *);
 static int  __rec_col_merge(WT_SESSION_IMPL *, WT_RECONCILE *, WT_PAGE *);
 static int  __rec_col_var(WT_SESSION_IMPL *,
-		WT_RECONCILE *, WT_PAGE *, WT_SALVAGE_COOKIE *);
+		WT_RECONCILE *, WT_REF *, WT_SALVAGE_COOKIE *);
 static int  __rec_col_var_helper(WT_SESSION_IMPL *, WT_RECONCILE *,
 		WT_SALVAGE_COOKIE *, WT_ITEM *, bool, uint8_t, uint64_t);
 static int  __rec_destroy_session(WT_SESSION_IMPL *);
@@ -391,16 +391,16 @@ __wt_reconcile(WT_SESSION_IMPL *session,
 	switch (page->type) {
 	case WT_PAGE_COL_FIX:
 		if (salvage != NULL)
-			ret = __rec_col_fix_slvg(session, r, page, salvage);
+			ret = __rec_col_fix_slvg(session, r, ref, salvage);
 		else
-			ret = __rec_col_fix(session, r, page);
+			ret = __rec_col_fix(session, r, ref);
 		break;
 	case WT_PAGE_COL_INT:
 		WT_WITH_PAGE_INDEX(session,
-		    ret = __rec_col_int(session, r, page));
+		    ret = __rec_col_int(session, r, ref));
 		break;
 	case WT_PAGE_COL_VAR:
-		ret = __rec_col_var(session, r, page, salvage);
+		ret = __rec_col_var(session, r, ref, salvage);
 		break;
 	case WT_PAGE_ROW_INT:
 		WT_WITH_PAGE_INDEX(session,
@@ -630,12 +630,12 @@ __rec_root_write(WT_SESSION_IMPL *session, WT_PAGE *page, uint32_t flags)
 	 */
 	switch (page->type) {
 	case WT_PAGE_COL_INT:
-		WT_RET(__wt_page_alloc(session, WT_PAGE_COL_INT,
-		    1, mod->mod_multi_entries, false, &next));
+		WT_RET(__wt_page_alloc(session,
+		    WT_PAGE_COL_INT, mod->mod_multi_entries, false, &next));
 		break;
 	case WT_PAGE_ROW_INT:
-		WT_RET(__wt_page_alloc(session, WT_PAGE_ROW_INT,
-		    WT_RECNO_OOB, mod->mod_multi_entries, false, &next));
+		WT_RET(__wt_page_alloc(session,
+		    WT_PAGE_ROW_INT, mod->mod_multi_entries, false, &next));
 		break;
 	WT_ILLEGAL_VALUE(session);
 	}
@@ -3787,7 +3787,7 @@ __rec_vtype(WT_ADDR *addr)
  *	Reconcile a column-store internal page.
  */
 static int
-__rec_col_int(WT_SESSION_IMPL *session, WT_RECONCILE *r, WT_PAGE *page)
+__rec_col_int(WT_SESSION_IMPL *session, WT_RECONCILE *r, WT_REF *pageref)
 {
 	WT_ADDR *addr;
 	WT_BTREE *btree;
@@ -3795,11 +3795,12 @@ __rec_col_int(WT_SESSION_IMPL *session, WT_RECONCILE *r, WT_PAGE *page)
 	WT_CHILD_STATE state;
 	WT_DECL_RET;
 	WT_KV *val;
-	WT_PAGE *child;
+	WT_PAGE *child, *page;
 	WT_REF *ref;
 	bool hazard;
 
 	btree = S2BT(session);
+	page = pageref->page;
 	child = NULL;
 	hazard = false;
 
@@ -3807,12 +3808,12 @@ __rec_col_int(WT_SESSION_IMPL *session, WT_RECONCILE *r, WT_PAGE *page)
 	vpack = &_vpack;
 
 	WT_RET(__rec_split_init(
-	    session, r, page, page->pg_intl_recno, btree->maxintlpage));
+	    session, r, page, pageref->ref_recno, btree->maxintlpage));
 
 	/* For each entry in the in-memory page... */
 	WT_INTL_FOREACH_BEGIN(session, page, ref) {
 		/* Update the starting record number in case we split. */
-		r->recno = ref->key.recno;
+		r->recno = ref->ref_recno;
 
 		/*
 		 * Modified child.
@@ -3886,7 +3887,7 @@ __rec_col_int(WT_SESSION_IMPL *session, WT_RECONCILE *r, WT_PAGE *page)
 		} else
 			__rec_cell_build_addr(session, r,
 			    addr->addr, addr->size,
-			    __rec_vtype(addr), ref->key.recno);
+			    __rec_vtype(addr), ref->ref_recno);
 		WT_CHILD_RELEASE_ERR(session, hazard, ref);
 
 		/* Boundary: split or write the page. */
@@ -3951,18 +3952,20 @@ __rec_col_merge(WT_SESSION_IMPL *session, WT_RECONCILE *r, WT_PAGE *page)
  *	Reconcile a fixed-width, column-store leaf page.
  */
 static int
-__rec_col_fix(WT_SESSION_IMPL *session, WT_RECONCILE *r, WT_PAGE *page)
+__rec_col_fix(WT_SESSION_IMPL *session, WT_RECONCILE *r, WT_REF *pageref)
 {
 	WT_BTREE *btree;
 	WT_INSERT *ins;
+	WT_PAGE *page;
 	WT_UPDATE *upd;
 	uint64_t recno;
 	uint32_t entry, nrecs;
 
 	btree = S2BT(session);
+	page = pageref->page;
 
 	WT_RET(__rec_split_init(
-	    session, r, page, page->pg_fix_recno, btree->maxleafpage));
+	    session, r, page, pageref->ref_recno, btree->maxleafpage));
 
 	/* Copy the original, disk-image bytes into place. */
 	memcpy(r->first_free, page->pg_fix_bitf,
@@ -3973,7 +3976,7 @@ __rec_col_fix(WT_SESSION_IMPL *session, WT_RECONCILE *r, WT_PAGE *page)
 		WT_RET(__rec_txn_read(session, r, ins, NULL, NULL, &upd));
 		if (upd != NULL)
 			__bit_setv(r->first_free,
-			    WT_INSERT_RECNO(ins) - page->pg_fix_recno,
+			    WT_INSERT_RECNO(ins) - pageref->ref_recno,
 			    btree->bitcnt, *(uint8_t *)WT_UPDATE_DATA(upd));
 	}
 
@@ -4077,13 +4080,15 @@ __rec_col_fix(WT_SESSION_IMPL *session, WT_RECONCILE *r, WT_PAGE *page)
  */
 static int
 __rec_col_fix_slvg(WT_SESSION_IMPL *session,
-    WT_RECONCILE *r, WT_PAGE *page, WT_SALVAGE_COOKIE *salvage)
+    WT_RECONCILE *r, WT_REF *pageref, WT_SALVAGE_COOKIE *salvage)
 {
 	WT_BTREE *btree;
+	WT_PAGE *page;
 	uint64_t page_start, page_take;
 	uint32_t entry, nrecs;
 
 	btree = S2BT(session);
+	page = pageref->page;
 
 	/*
 	 * !!!
@@ -4098,7 +4103,7 @@ __rec_col_fix_slvg(WT_SESSION_IMPL *session,
 	 * don't want to have to retrofit the code later.
 	 */
 	WT_RET(__rec_split_init(
-	    session, r, page, page->pg_fix_recno, btree->maxleafpage));
+	    session, r, page, pageref->ref_recno, btree->maxleafpage));
 
 	/* We may not be taking all of the entries on the original page. */
 	page_take = salvage->take == 0 ? page->pg_fix_entries : salvage->take;
@@ -4221,7 +4226,7 @@ __rec_col_var_helper(WT_SESSION_IMPL *session, WT_RECONCILE *r,
  */
 static int
 __rec_col_var(WT_SESSION_IMPL *session,
-    WT_RECONCILE *r, WT_PAGE *page, WT_SALVAGE_COOKIE *salvage)
+    WT_RECONCILE *r, WT_REF *pageref, WT_SALVAGE_COOKIE *salvage)
 {
 	enum { OVFL_IGNORE, OVFL_UNUSED, OVFL_USED } ovfl_state;
 	WT_BTREE *btree;
@@ -4232,6 +4237,7 @@ __rec_col_var(WT_SESSION_IMPL *session,
 	WT_DECL_RET;
 	WT_INSERT *ins;
 	WT_ITEM *last;
+	WT_PAGE *page;
 	WT_UPDATE *upd;
 	uint64_t n, nrepeat, repeat_count, rle, skip, src_recno;
 	uint32_t i, size;
@@ -4239,6 +4245,7 @@ __rec_col_var(WT_SESSION_IMPL *session,
 	const void *data;
 
 	btree = S2BT(session);
+	page = pageref->page;
 	last = r->last;
 	vpack = &_vpack;
 
@@ -4248,7 +4255,7 @@ __rec_col_var(WT_SESSION_IMPL *session,
 	upd = NULL;
 
 	WT_RET(__rec_split_init(
-	    session, r, page, page->pg_var_recno, btree->maxleafpage));
+	    session, r, page, pageref->ref_recno, btree->maxleafpage));
 
 	/*
 	 * The salvage code may be calling us to reconcile a page where there