diff --git a/vm/data_gc.cpp b/vm/data_gc.cpp
index 48c07e7c60..89f3375c11 100755
--- a/vm/data_gc.cpp
+++ b/vm/data_gc.cpp
@@ -555,7 +555,7 @@ void factor_vm::collect_nursery()
 void factor_vm::collect_aging()
 {
 	std::swap(data->generations[data->aging()],data->semispaces[data->aging()]);
-	reset_generations(data->aging(),data->aging());
+	reset_generation(data->aging());
 
 	aging_collector collector(this,&data->generations[data->aging()]);
 
@@ -566,7 +566,7 @@ void factor_vm::collect_aging()
 	collector.go();
 	update_dirty_code_blocks();
 
-	reset_generations(data->nursery(),data->nursery());
+	nursery.here = nursery.start;
 }
 
 void factor_vm::collect_aging_again()
@@ -580,7 +580,8 @@ void factor_vm::collect_aging_again()
 	collector.go();
 	update_dirty_code_blocks();
 
-	reset_generations(data->nursery(),data->aging());
+	reset_generation(data->aging());
+	nursery.here = nursery.start;
 }
 
 void factor_vm::collect_tenured(cell requested_bytes, bool trace_contexts_)
@@ -593,7 +594,7 @@ void factor_vm::collect_tenured(cell requested_bytes, bool trace_contexts_)
 	else
 	{
 		std::swap(data->generations[data->tenured()],data->semispaces[data->tenured()]);
-		reset_generations(data->tenured(),data->tenured());
+		reset_generation(data->tenured());
 	}
 
 	tenured_collector collector(this,&data->generations[data->tenured()]);
@@ -603,7 +604,8 @@ void factor_vm::collect_tenured(cell requested_bytes, bool trace_contexts_)
         collector.go();
         free_unmarked_code_blocks();
 
-	reset_generations(data->nursery(),data->aging());
+	reset_generation(data->aging());
+	nursery.here = nursery.start;
 
 	if(current_gc->growing_data_heap)
 		delete current_gc->old_data_heap;
diff --git a/vm/data_heap.cpp b/vm/data_heap.cpp
index d43d70e963..d5cfbb449d 100755
--- a/vm/data_heap.cpp
+++ b/vm/data_heap.cpp
@@ -76,60 +76,52 @@ data_heap::~data_heap()
 	delete[] decks;
 }
 
-void factor_vm::clear_cards(cell from, cell to)
+void factor_vm::clear_cards(cell gen)
 {
 	/* NOTE: reverse order due to heap layout. */
-	card *first_card = addr_to_card(data->generations[to].start);
-	card *last_card = addr_to_card(data->generations[from].end);
+	card *first_card = addr_to_card(data->generations[gen].start);
+	card *last_card = addr_to_card(data->generations[gen].end);
 	memset(first_card,0,last_card - first_card);
 }
 
-void factor_vm::clear_decks(cell from, cell to)
+void factor_vm::clear_decks(cell gen)
 {
 	/* NOTE: reverse order due to heap layout. */
-	card_deck *first_deck = addr_to_deck(data->generations[to].start);
-	card_deck *last_deck = addr_to_deck(data->generations[from].end);
+	card_deck *first_deck = addr_to_deck(data->generations[gen].start);
+	card_deck *last_deck = addr_to_deck(data->generations[gen].end);
 	memset(first_deck,0,last_deck - first_deck);
 }
 
-void factor_vm::clear_allot_markers(cell from, cell to)
+void factor_vm::clear_allot_markers(cell gen)
 {
-	/* NOTE: reverse order due to heap layout. */
-	card *first_card = addr_to_allot_marker((object *)data->generations[to].start);
-	card *last_card = addr_to_allot_marker((object *)data->generations[from].end);
+	card *first_card = addr_to_allot_marker((object *)data->generations[gen].start);
+	card *last_card = addr_to_allot_marker((object *)data->generations[gen].end);
 	memset(first_card,invalid_allot_marker,last_card - first_card);
 }
 
-void factor_vm::reset_generation(cell i)
-{
-	zone *z = (i == data->nursery() ? &nursery : &data->generations[i]);
-
-	z->here = z->start;
-	if(secure_gc)
-		memset((void*)z->start,69,z->size);
-}
-
 /* After garbage collection, any generations which are now empty need to have
 their allocation pointers and cards reset. */
-void factor_vm::reset_generations(cell from, cell to)
+void factor_vm::reset_generation(cell gen)
 {
-	cell i;
-	for(i = from; i <= to; i++)
-		reset_generation(i);
+	assert(gen != data->nursery());
 
-	clear_cards(from,to);
-	clear_decks(from,to);
-	clear_allot_markers(from,to);
+	zone *z = &data->generations[gen];
+	z->here = z->start;
+	if(secure_gc) memset((void*)z->start,69,z->size);
+
+	clear_cards(gen);
+	clear_decks(gen);
+	clear_allot_markers(gen);
 }
 
 void factor_vm::set_data_heap(data_heap *data_)
 {
 	data = data_;
 	nursery = data->generations[data->nursery()];
+	nursery.here = nursery.start;
 	init_card_decks();
-	clear_cards(data->nursery(),data->tenured());
-	clear_decks(data->nursery(),data->tenured());
-	clear_allot_markers(data->nursery(),data->tenured());
+	reset_generation(data->aging());
+	reset_generation(data->tenured());
 }
 
 void factor_vm::init_data_heap(cell young_size, cell aging_size, cell tenured_size, bool secure_gc_)
diff --git a/vm/vm.hpp b/vm/vm.hpp
index cb24ce8456..d39163a209 100755
--- a/vm/vm.hpp
+++ b/vm/vm.hpp
@@ -151,11 +151,10 @@ struct factor_vm
 
 	void init_card_decks();
 	data_heap *grow_data_heap(data_heap *data, cell requested_bytes);
-	void clear_cards(cell from, cell to);
-	void clear_decks(cell from, cell to);
-	void clear_allot_markers(cell from, cell to);
-	void reset_generation(cell i);
-	void reset_generations(cell from, cell to);
+	void clear_cards(cell gen);
+	void clear_decks(cell gen);
+	void clear_allot_markers(cell gen);
+	void reset_generation(cell gen);
 	void set_data_heap(data_heap *data_);
 	void init_data_heap(cell young_size, cell aging_size, cell tenured_size, bool secure_gc_);
 	cell untagged_object_size(object *pointer);