Identity · Eight-level nested chain

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct L0 { int64_t value; } L0;
typedef struct L1 { L0 *child; } L1;
typedef struct L2 { L1 *child; } L2;
typedef struct L3 { L2 *child; } L3;
typedef struct L4 { L3 *child; } L4;
typedef struct L5 { L4 *child; } L5;
typedef struct L6 { L5 *child; } L6;
typedef struct L7 { L6 *child; } L7;
static volatile uintptr_t identity_sink;
int main(int argc, char **argv) {
    int64_t n = argc > 1 ? atoll(argv[1]) : 4000000, checksum = 0;
    for (int64_t i = 0; i < n; ++i) {
        L0 *l0 = malloc(sizeof(*l0)); *l0 = (L0){i};
        L1 *l1 = malloc(sizeof(*l1)); *l1 = (L1){l0};
        L2 *l2 = malloc(sizeof(*l2)); *l2 = (L2){l1};
        L3 *l3 = malloc(sizeof(*l3)); *l3 = (L3){l2};
        L4 *l4 = malloc(sizeof(*l4)); *l4 = (L4){l3};
        L5 *l5 = malloc(sizeof(*l5)); *l5 = (L5){l4};
        L6 *l6 = malloc(sizeof(*l6)); *l6 = (L6){l5};
        L7 *l7 = malloc(sizeof(*l7)); *l7 = (L7){l6};
        identity_sink ^= (uintptr_t)l7;
        checksum = (checksum + l7->child->child->child->child->child->child->child->value) % 1000003;
    }
    printf("%" PRId64 "\n", checksum);
}

construct L0 { let value: Int }
construct L1 { let child: L0 }
construct L2 { let child: L1 }
construct L3 { let child: L2 }
construct L4 { let child: L3 }
construct L5 { let child: L4 }
construct L6 { let child: L5 }
construct L7 { let child: L6 }
@main {
    state i: Int(0)
    state checksum: Int(0)
    while i < 4000000 {
        let root: L7(child: L6(child: L5(child: L4(child: L3(child: L2(child: L1(child: L0(value: i))))))))
        checksum: (checksum + root.child.child.child.child.child.child.child.value) % 1000003
        i: i + 1
    }
    return checksum % 251
}