// Hand-C reference for bench_tree_walk.
//
// Same algorithm as examples/bench_tree_walk.ailx — build a balanced
// binary tree of given depth (every value = 1) and sum every node.
// Three depths: 16 / 18 / 20 (= 65535 / 262143 / 1048575 nodes).
//
// Cell layout: { long value; struct node *left; struct node *right; }
// — 24 bytes. AILang's Tree Node cell is 32 bytes (tag + value + l
// + r) due to the discriminated-union tag. The Leaf variant is also
// boxed in AILang (tag-only, ~8 bytes). For C, we use NULL pointers
// for leaves (no allocation), which is a representation choice that
// favors C; a fair-er comparison would tag leaves explicitly.
//
// Memory policy: malloc, DELIBERATELY no free. Matches AILang's
// bench_tree_walk under --alloc=rc (implicit-mode, leaks).
//
// Build: clang -O2 -o tree_walk tree_walk.c
// Expected stdout (one int per line):
//   65535
//   262143
//   1048575

#include <stdio.h>
#include <stdlib.h>

typedef struct node {
    long value;
    struct node *left;
    struct node *right;
} node_t;

static node_t *build_tree(long depth) {
    if (depth == 0) return NULL;
    node_t *n = (node_t *) malloc(sizeof(node_t));
    n->value = 1;
    n->left  = build_tree(depth - 1);
    n->right = build_tree(depth - 1);
    return n;
}

static long sum_tree(const node_t *t) {
    if (t == NULL) return 0;
    return t->value + sum_tree(t->left) + sum_tree(t->right);
}

static void run_one(long depth) {
    const node_t *t = build_tree(depth);
    printf("%ld\n", sum_tree(t));
}

int main(void) {
    run_one(16);
    run_one(18);
    run_one(20);
    return 0;
}