Workload

1. Recursively construct a balanced binary tree of depth 15 (2¹⁶ − 1 = 65535 nodes). Each node's value is derived deterministically from its parent (value*2 for left, value*2+1 for right, 32-bit masked).
2. Count nodes via recursive traversal (sanity check).
3. Compute an in-order hash fold: state = state*31 + value mod 2³².
4. Invert the tree: at every node, swap left and right pointers recursively.
5. Re-count and re-hash. Emit the four observables pre_count,pre_fold,post_count,post_fold.

Symmetry rules

• Real recursive *Node struct (Go) / Node class with __slots__ (Python).
• No conversion to arrays for the inversion step, just a pointer swap at every node.

What makes this workload unique

Every other benchmark in the suite isolates one performance dimension. Bench 14 stresses pure float arithmetic in a tight loop. Bench 15 stresses interpreter throughput with no allocation. Bench 13 stresses interface dispatch with no mutation. This one combines three pressures into a single inner loop: 65k heap allocations during construction, four full recursive walks across the tree, and in-place pointer-field mutation during the inversion. The runner that wins this benchmark is the runner whose allocator, call-frame management, and pointer-write path are all simultaneously fast. The runner that loses it has a bottleneck in at least one of the three.