namespace;
include rt;

// repeated allocations of a size known at compile time: new(T) of a struct of
// numbers, and new(n) with a constant n. each pass of the loop makes an object
// and frees it at the end of the block, so the allocator should hand back the
// block it just took. the sums prove the objects were zeroed every time.
struct point { int x, y; };
struct line { point* a; int len; };

fn loop_leaf(int n) {
	let total = 0;
	for (int i = 0; i < n; i++) {
		point* p = rt.new(point);
		total += p.x + p.y;		// zero from the allocator, every pass
		p.x = i; p.y = 2;
	}
	return total;
}
fn loop_words(int n) {
	let total = 0, i = 0;
	while (i < n) {
		let w = rt.new(6);
		total += w[0] + w[5];
		w[0] = 7; w[5] = 9;
		i++;
	}
	return total;
}
fn loop_owner(int n) {
	let i = 0, total = 0;
	while (i < n) {
		line* l = rt.new(line);
		l.a = rt.new(point);
		l.a.x = i;
		total += l.a.x + l.len;
		i++;
	}
	return total;
}
fn main() {
	let before = rt.live_objects();
	rt.put_n(loop_leaf(50000)); rt.put_c(' ');
	rt.put_n(loop_words(50000)); rt.put_c(' ');
	rt.put_n(loop_owner(1000)); rt.put_c(' ');
	rt.put_n(rt.live_objects() - before); rt.put_c(10);
	return 0;
}