if (paths[node][0] === -1) return men > 0 ? 1 : 0;

if (node === null) return 0;

if (node === null) return;

if (node === null) return;

if (root === null) return { val, left: null, right: null };

if (root === null) return null;

if (node === null) return;

if (!root) return null;
if (root === node1 || root === node2) return root;

if (root === null) return -1;

if (!root) { res.push("x"); return; }

// (handled by n-ary loop — leaf: node.children is empty)

if (node === null) return 0;

if (root === null) return 0;

if (!root) return true;

if (!node) return 0;

if (node === null) return;

if (node === null) return -Infinity;

if (node.children.length === 0) {
  res.push([...path, node.val].join('->'));
  return;
}

if (!node) return [0, 0];

for (let i = 0; i < childCount; i++) {
  const portion = Math.floor(remaining / (childCount - i));
  remaining -= portion;

const left = dfs(node.left);
if (left === -1) return -1;
const right = dfs(node.right);
if (right === -1) return -1;

dfs(node.left);

dfs(node.right);
dfs(node.left);

if (val < root.val) root.left = insertIntoBST(root.left, val);
else if (val > root.val) root.right = insertIntoBST(root.right, val);

const left = invertTree(root.left);
const right = invertTree(root.right);

dfs(node.left);
if (count === 0) return;

const left = lca(root.left, node1, node2);
const right = lca(root.right, node1, node2);

if (p < root.val && q < root.val) return lowestCommonAncestorBST(root.left, p, q);
if (p > root.val && q > root.val) return lowestCommonAncestorBST(root.right, p, q);

res.push(root.val);
serializeDFS(root.left, res);
serializeDFS(root.right, res);

for (const child of node.children) {
  const [childSum, childCount] = dfs(child);
  sum += childSum;
  count += childCount;
}

const left = depth(node.left);
const right = depth(node.right);

// (inlined — no separate variables needed)

// (bounds threading — not standard left/right returns)
return dfs(root.left, minVal, root.val) && dfs(root.right, root.val, maxVal);

const left = dfs(node.left, Math.max(maxSoFar, node.val));
const right = dfs(node.right, Math.max(maxSoFar, node.val));

for (const child of node.children ?? []) {
  visit(child);
}

const left = dfs(node.left);
const right = dfs(node.right);

for (const child of node.children) {
  if (child) {

for (const child of (node.children ?? [])) {
  const [childSum, childCount] = dfs(child);
  sum += childSum;
  count += childCount;
}

  totalCaught += probability(children[i], portion) / childCount;
}

return 1 + Math.max(left, right);

if (result.length < k) {
  result.push(node.val);
} else if (Math.abs(node.val - x) < Math.abs(result[0] - x)) {
  result.shift();
  result.push(node.val);
} else {
  return;
}

node.right = prev;
node.left = null;
prev = node;

return root;

root.left = right;
root.right = left;
return root;

count--;
if (count === 0) { result = node.val; return; }
dfs(node.right);

if (left && right) return root;
return left || right;

return root.val;

const avg = sum / count;
if (avg > bestAvg) { bestAvg = avg; bestNode = node; }
return [sum, count];

best = Math.max(best, left + right);
return 1 + Math.max(left, right);

return Math.max(dfs(root.left), dfs(root.right)) + 1;

if (!(minVal < root.val && root.val < maxVal)) return false;

const visible = node.val >= maxSoFar ? 1 : 0;
return visible + left + right;

result.push(node.val);

return Math.max(node.val, left, right);

    dfs(child, path);

if (isManager) {
  const avg = sum / count;
  if (avg > bestAvg) { bestAvg = avg; bestNode = node; }
}
return [sum, count];