void codegen(int *ca, int prn) {
  int delay[] = {5,   6,   7,   8,   17,  18,  139, 140, 141, 251, 252,
                 254, 255, 256, 257, 258, 469, 470, 471, 472, 473, 474,
                 509, 512, 513, 514, 515, 516, 859, 860, 861, 862};
  int g1[(1023)], g2[(1023)];
  int r1[(10)], r2[(10)];
  int c1, c2;
  int i, j;
  if (prn < 1 || prn > 32)
    return;
  for (i = 0; i < (10); i++)
    r1[i] = r2[i] = -1;
  for (i = 0; i < (1023); i++) {
    g1[i] = r1[9];
    g2[i] = r2[9];
    c1 = r1[2] * r1[9];
    c2 = r2[1] * r2[2] * r2[5] * r2[7] * r2[8] * r2[9];
    for (j = 9; j > 0; j--) {
      r1[j] = r1[j - 1];
      r2[j] = r2[j - 1];
    }
    r1[0] = c1;
    r2[0] = c2;
  }
  for (i = 0, j = (1023) - delay[prn - 1]; i < (1023); i++, j++)
    ca[i] = (1 - g1[i] * g2[j % (1023)]) / 2;
  return;
}


x86 assembly (clang, -O0):
<codegen>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2100,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
lea    -0x90(%rbp),%rdi
lea    0xed0(%rip),%rsi
mov    $0x80,%edx
call   1030 <memcpy@plt>
cmpl   $0x1,-0xc(%rbp)
jl     114e <codegen+0x3e>
cmpl   $0x20,-0xc(%rbp)
jle    1153 <codegen+0x43>
jmp    1360 <codegen+0x250>
movl   $0x0,-0x20fc(%rbp)
cmpl   $0xa,-0x20fc(%rbp)
jge    11a2 <codegen+0x92>
movslq -0x20fc(%rbp),%rax
movl   $0xffffffff,-0x20f0(%rbp,%rax,4)
ff ff ff ff
movslq -0x20fc(%rbp),%rax
movl   $0xffffffff,-0x20c0(%rbp,%rax,4)
ff ff ff ff
mov    -0x20fc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20fc(%rbp)
jmp    115d <codegen+0x4d>
movl   $0x0,-0x20fc(%rbp)
cmpl   $0x3ff,-0x20fc(%rbp)
jge    12bd <codegen+0x1ad>
mov    -0x209c(%rbp),%ecx
movslq -0x20fc(%rbp),%rax
mov    %ecx,-0x1090(%rbp,%rax,4)
mov    -0x20cc(%rbp),%ecx
movslq -0x20fc(%rbp),%rax
mov    %ecx,-0x2090(%rbp,%rax,4)
mov    -0x20b8(%rbp),%eax
imul   -0x209c(%rbp),%eax
mov    %eax,-0x20f4(%rbp)
mov    -0x20ec(%rbp),%eax
imul   -0x20e8(%rbp),%eax
imul   -0x20dc(%rbp),%eax
imul   -0x20d4(%rbp),%eax
imul   -0x20d0(%rbp),%eax
imul   -0x20cc(%rbp),%eax
mov    %eax,-0x20f8(%rbp)
movl   $0x9,-0x2100(%rbp)
cmpl   $0x0,-0x2100(%rbp)
jle    1291 <codegen+0x181>
mov    -0x2100(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x20c0(%rbp,%rax,4),%ecx
movslq -0x2100(%rbp),%rax
mov    %ecx,-0x20c0(%rbp,%rax,4)
mov    -0x2100(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x20f0(%rbp,%rax,4),%ecx
movslq -0x2100(%rbp),%rax
mov    %ecx,-0x20f0(%rbp,%rax,4)
mov    -0x2100(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2100(%rbp)
jmp    1230 <codegen+0x120>
mov    -0x20f4(%rbp),%eax
mov    %eax,-0x20c0(%rbp)
mov    -0x20f8(%rbp),%eax
mov    %eax,-0x20f0(%rbp)
mov    -0x20fc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20fc(%rbp)
jmp    11ac <codegen+0x9c>
movl   $0x0,-0x20fc(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
mov    $0x3ff,%eax
sub    -0x90(%rbp,%rcx,4),%eax
mov    %eax,-0x2100(%rbp)
cmpl   $0x3ff,-0x20fc(%rbp)
jge    135b <codegen+0x24b>
movslq -0x20fc(%rbp),%rax
mov    -0x1090(%rbp,%rax,4),%ecx
mov    -0x2100(%rbp),%eax
mov    $0x3ff,%esi
cltd
idiv   %esi
movslq %edx,%rax
imul   -0x2090(%rbp,%rax,4),%ecx
ff
mov    $0x1,%eax
sub    %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0x8(%rbp),%rax
movslq -0x20fc(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20fc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20fc(%rbp)
mov    -0x2100(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2100(%rbp)
jmp    12e2 <codegen+0x1d2>
jmp    1360 <codegen+0x250>
add    $0x2100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<codegen>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x1fe8,%rsp
lea    -0x21(%rsi),%eax
cmp    $0xffffffe0,%eax
jb     1286 <codegen+0x186>
pcmpeqd %xmm0,%xmm0
movdqa %xmm0,-0x70(%rsp)
movdqa %xmm0,-0x80(%rsp)
movq   $0xffffffffffffffff,-0x60(%rsp)
ff ff
movdqa %xmm0,-0x50(%rsp)
movdqa %xmm0,-0x40(%rsp)
movq   $0xffffffffffffffff,-0x30(%rsp)
ff ff
lea    -0x7c(%rsp),%r8
mov    $0xffffffff,%eax
lea    -0x4c(%rsp),%r9
xor    %edx,%edx
mov    $0xffffffff,%r15d
mov    $0xffffffff,%ebx
mov    $0xffffffff,%r14d
mov    $0xffffffff,%ecx
mov    $0xffffffff,%r11d
mov    $0xffffffff,%ebp
mov    $0xffffffff,%r10d
nop
imul   %r15d,%eax
imul   %r14d,%ebx
mov    %r10d,0xfe0(%rsp,%rdx,4)
mov    %ebp,-0x20(%rsp,%rdx,4)
imul   %ebp,%ecx
imul   %ebx,%ecx
imul   %eax,%ecx
movaps -0x50(%rsp),%xmm0
movaps -0x40(%rsp),%xmm1
mov    -0x30(%rsp),%eax
mov    %eax,0x20(%r9)
movups %xmm1,0x10(%r9)
movups %xmm0,(%r9)
movdqa -0x80(%rsp),%xmm0
movaps -0x70(%rsp),%xmm1
mov    -0x60(%rsp),%eax
mov    %eax,0x20(%r8)
movups %xmm1,0x10(%r8)
movdqu %xmm0,(%r8)
imul   %r10d,%r11d
mov    %r11d,-0x50(%rsp)
mov    %ecx,-0x80(%rsp)
cmp    $0x3fe,%rdx
je     1218 <codegen+0x118>
mov    -0x48(%rsp),%r11d
mov    -0x2c(%rsp),%r10d
mov    -0x5c(%rsp),%ebp
mov    -0x7c(%rsp),%ecx
mov    -0x78(%rsp),%r14d
mov    -0x6c(%rsp),%ebx
mov    -0x64(%rsp),%r15d
mov    -0x60(%rsp),%eax
add    $0x1,%rdx
jmp    1180 <codegen+0x80>
add    $0xffffffff,%esi
lea    0xdde(%rip),%rcx
mov    $0x3ff,%eax
sub    (%rcx,%rsi,4),%eax
xor    %ecx,%ecx
nopl   0x0(%rax)
lea    (%rax,%rcx,1),%rdx
movslq %edx,%rdx
imul   $0xffffffff80200803,%rdx,%rsi
shr    $0x20,%rsi
add    %edx,%esi
mov    %esi,%ebp
shr    $0x1f,%ebp
sar    $0x9,%esi
add    %ebp,%esi
mov    %esi,%ebp
shl    $0xa,%ebp
sub    %ebp,%esi
add    %edx,%esi
movslq %esi,%rdx
mov    -0x20(%rsp,%rdx,4),%edx
imul   0xfe0(%rsp,%rcx,4),%edx
mov    $0x1,%esi
sub    %edx,%esi
mov    %esi,%edx
shr    $0x1f,%edx
add    %esi,%edx
sar    %edx
mov    %edx,(%rdi,%rcx,4)
add    $0x1,%rcx
cmp    $0x3ff,%rcx
jne    1230 <codegen+0x130>
add    $0x1fe8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@__const.codegen.delay = [32 x i32] [i32 5, i32 6, i32 7, i32 8, i32 17, i32 18, i32 139, i32 140, i32 141, i32 251, i32 252, i32 254, i32 255, i32 256, i32 257, i32 258, i32 469, i32 470, i32 471, i32 472, i32 473, i32 474, i32 509, i32 512, i32 513, i32 514, i32 515, i32 516, i32 859, i32 860, i32 861, i32 862]
define void @codegen(i32* %0, i32 %1) {
%3 = alloca i32*
%4 = alloca i32
%5 = alloca [32 x i32]
%6 = alloca [1023 x i32]
%7 = alloca [1023 x i32]
%8 = alloca [10 x i32]
%9 = alloca [10 x i32]
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
store i32* %0, i32** %3
store i32 %1, i32* %4
%14 = bitcast [32 x i32]* %5 to i8*
%15 = load i32, i32* %4
%16 = icmp slt i32 %15, 1
br i1 %16, label %20, label %17
17: ; preds = %2
%18 = load i32, i32* %4
%19 = icmp sgt i32 %18, 32
br i1 %19, label %20, label %21
20: ; preds = %17, %2
br label %136
21: ; preds = %17
store i32 0, i32* %12
br label %22
22: ; preds = %32, %21
%23 = load i32, i32* %12
%24 = icmp slt i32 %23, 10
br i1 %24, label %25, label %35
25: ; preds = %22
%26 = load i32, i32* %12
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds [10 x i32], [10 x i32]* %9, i64 0, i64 %27
store i32 -1, i32* %28
%29 = load i32, i32* %12
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds [10 x i32], [10 x i32]* %8, i64 0, i64 %30
store i32 -1, i32* %31
br label %32
32: ; preds = %25
%33 = load i32, i32* %12
%34 = add nsw i32 %33, 1
store i32 %34, i32* %12
br label %22
35: ; preds = %22
store i32 0, i32* %12
br label %36
36: ; preds = %100, %35
%37 = load i32, i32* %12
%38 = icmp slt i32 %37, 1023
br i1 %38, label %39, label %103
39: ; preds = %36
%40 = getelementptr inbounds [10 x i32], [10 x i32]* %8, i64 0, i64 9
%41 = load i32, i32* %40
%42 = load i32, i32* %12
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds [1023 x i32], [1023 x i32]* %6, i64 0, i64 %43
store i32 %41, i32* %44
%45 = getelementptr inbounds [10 x i32], [10 x i32]* %9, i64 0, i64 9
%46 = load i32, i32* %45
%47 = load i32, i32* %12
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds [1023 x i32], [1023 x i32]* %7, i64 0, i64 %48
store i32 %46, i32* %49
%50 = getelementptr inbounds [10 x i32], [10 x i32]* %8, i64 0, i64 2
%51 = load i32, i32* %50
%52 = getelementptr inbounds [10 x i32], [10 x i32]* %8, i64 0, i64 9
%53 = load i32, i32* %52
%54 = mul nsw i32 %51, %53
store i32 %54, i32* %10
%55 = getelementptr inbounds [10 x i32], [10 x i32]* %9, i64 0, i64 1
%56 = load i32, i32* %55
%57 = getelementptr inbounds [10 x i32], [10 x i32]* %9, i64 0, i64 2
%58 = load i32, i32* %57
%59 = mul nsw i32 %56, %58
%60 = getelementptr inbounds [10 x i32], [10 x i32]* %9, i64 0, i64 5
%61 = load i32, i32* %60
%62 = mul nsw i32 %59, %61
%63 = getelementptr inbounds [10 x i32], [10 x i32]* %9, i64 0, i64 7
%64 = load i32, i32* %63
%65 = mul nsw i32 %62, %64
%66 = getelementptr inbounds [10 x i32], [10 x i32]* %9, i64 0, i64 8
%67 = load i32, i32* %66
%68 = mul nsw i32 %65, %67
%69 = getelementptr inbounds [10 x i32], [10 x i32]* %9, i64 0, i64 9
%70 = load i32, i32* %69
%71 = mul nsw i32 %68, %70
store i32 %71, i32* %11
store i32 9, i32* %13
br label %72
72: ; preds = %92, %39
%73 = load i32, i32* %13
%74 = icmp sgt i32 %73, 0
br i1 %74, label %75, label %95
75: ; preds = %72
%76 = load i32, i32* %13
%77 = sub nsw i32 %76, 1
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [10 x i32], [10 x i32]* %8, i64 0, i64 %78
%80 = load i32, i32* %79
%81 = load i32, i32* %13
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds [10 x i32], [10 x i32]* %8, i64 0, i64 %82
store i32 %80, i32* %83
%84 = load i32, i32* %13
%85 = sub nsw i32 %84, 1
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds [10 x i32], [10 x i32]* %9, i64 0, i64 %86
%88 = load i32, i32* %87
%89 = load i32, i32* %13
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds [10 x i32], [10 x i32]* %9, i64 0, i64 %90
store i32 %88, i32* %91
br label %92
92: ; preds = %75
%93 = load i32, i32* %13
%94 = add nsw i32 %93, -1
store i32 %94, i32* %13
br label %72
95: ; preds = %72
%96 = load i32, i32* %10
%97 = getelementptr inbounds [10 x i32], [10 x i32]* %8, i64 0, i64 0
store i32 %96, i32* %97
%98 = load i32, i32* %11
%99 = getelementptr inbounds [10 x i32], [10 x i32]* %9, i64 0, i64 0
store i32 %98, i32* %99
br label %100
100: ; preds = %95
%101 = load i32, i32* %12
%102 = add nsw i32 %101, 1
store i32 %102, i32* %12
br label %36
103: ; preds = %36
store i32 0, i32* %12
%104 = load i32, i32* %4
%105 = sub nsw i32 %104, 1
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 %106
%108 = load i32, i32* %107
%109 = sub nsw i32 1023, %108
store i32 %109, i32* %13
br label %110
110: ; preds = %130, %103
%111 = load i32, i32* %12
%112 = icmp slt i32 %111, 1023
br i1 %112, label %113, label %135
113: ; preds = %110
%114 = load i32, i32* %12
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds [1023 x i32], [1023 x i32]* %6, i64 0, i64 %115
%117 = load i32, i32* %116
%118 = load i32, i32* %13
%119 = srem i32 %118, 1023
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [1023 x i32], [1023 x i32]* %7, i64 0, i64 %120
%122 = load i32, i32* %121
%123 = mul nsw i32 %117, %122
%124 = sub nsw i32 1, %123
%125 = sdiv i32 %124, 2
%126 = load i32*, i32** %3
%127 = load i32, i32* %12
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i32, i32* %126, i64 %128
store i32 %125, i32* %129
br label %130
130: ; preds = %113
%131 = load i32, i32* %12
%132 = add nsw i32 %131, 1
store i32 %132, i32* %12
%133 = load i32, i32* %13
%134 = add nsw i32 %133, 1
store i32 %134, i32* %13
br label %110
135: ; preds = %110
br label %136
136: ; preds = %135, %20
ret void
}

LLVM IR (-O2):
@__const.codegen.delay = [32 x i32] [i32 5, i32 6, i32 7, i32 8, i32 17, i32 18, i32 139, i32 140, i32 141, i32 251, i32 252, i32 254, i32 255, i32 256, i32 257, i32 258, i32 469, i32 470, i32 471, i32 472, i32 473, i32 474, i32 509, i32 512, i32 513, i32 514, i32 515, i32 516, i32 859, i32 860, i32 861, i32 862]
define void @codegen(i32* nocapture writeonly %0, i32 %1) {
%3 = alloca [1023 x i32]
%4 = alloca [1023 x i32]
%5 = alloca [10 x i32]
%6 = alloca [10 x i32]
%7 = bitcast [1023 x i32]* %3 to i8*
%8 = bitcast [1023 x i32]* %4 to i8*
%9 = bitcast [10 x i32]* %5 to i8*
%10 = bitcast [10 x i32]* %6 to i8*
%11 = add i32 %1, -33
%12 = icmp ult i32 %11, -32
br i1 %12, label %78, label %13
13: ; preds = %2
%14 = getelementptr inbounds [10 x i32], [10 x i32]* %6, i64 0, i64 1
%15 = getelementptr inbounds [10 x i32], [10 x i32]* %5, i64 0, i64 1
%16 = bitcast i32* %15 to i8*
%17 = bitcast i32* %14 to i8*
%18 = getelementptr inbounds [10 x i32], [10 x i32]* %5, i64 0, i64 0
%19 = getelementptr inbounds [10 x i32], [10 x i32]* %6, i64 0, i64 0
%20 = getelementptr inbounds [10 x i32], [10 x i32]* %6, i64 0, i64 8
%21 = getelementptr inbounds [10 x i32], [10 x i32]* %6, i64 0, i64 7
%22 = getelementptr inbounds [10 x i32], [10 x i32]* %6, i64 0, i64 5
%23 = getelementptr inbounds [10 x i32], [10 x i32]* %6, i64 0, i64 2
%24 = getelementptr inbounds [10 x i32], [10 x i32]* %5, i64 0, i64 2
%25 = getelementptr inbounds [10 x i32], [10 x i32]* %6, i64 0, i64 9
%26 = getelementptr inbounds [10 x i32], [10 x i32]* %5, i64 0, i64 9
br label %27
27: ; preds = %47, %13
%28 = phi i32 [ -1, %13 ], [ %55, %47 ]
%29 = phi i32 [ -1, %13 ], [ %54, %47 ]
%30 = phi i32 [ -1, %13 ], [ %53, %47 ]
%31 = phi i32 [ -1, %13 ], [ %52, %47 ]
%32 = phi i32 [ -1, %13 ], [ %51, %47 ]
%33 = phi i32 [ -1, %13 ], [ %50, %47 ]
%34 = phi i32 [ -1, %13 ], [ %49, %47 ]
%35 = phi i32 [ -1, %13 ], [ %48, %47 ]
%36 = phi i64 [ 0, %13 ], [ %45, %47 ]
%37 = getelementptr inbounds [1023 x i32], [1023 x i32]* %3, i64 0, i64 %36
store i32 %35, i32* %37
%38 = getelementptr inbounds [1023 x i32], [1023 x i32]* %4, i64 0, i64 %36
store i32 %34, i32* %38
%39 = mul i32 %32, %34
%40 = mul i32 %39, %31
%41 = mul i32 %40, %30
%42 = mul i32 %41, %29
%43 = mul nsw i32 %33, %35
%44 = mul i32 %42, %28
store i32 %43, i32* %18
store i32 %44, i32* %19
%45 = add nuw nsw i64 %36, 1
%46 = icmp eq i64 %45, 1023
br i1 %46, label %56, label %47
47: ; preds = %27
%48 = load i32, i32* %26
%49 = load i32, i32* %25
%50 = load i32, i32* %24
%51 = load i32, i32* %14
%52 = load i32, i32* %23
%53 = load i32, i32* %22
%54 = load i32, i32* %21
%55 = load i32, i32* %20
br label %27
56: ; preds = %27
%57 = add nsw i32 %1, -1
%58 = zext i32 %57 to i64
%59 = getelementptr inbounds [32 x i32], [32 x i32]* @__const.codegen.delay, i64 0, i64 %58
%60 = load i32, i32* %59
%61 = sub nsw i32 1023, %60
br label %62
62: ; preds = %56, %62
%63 = phi i64 [ 0, %56 ], [ %75, %62 ]
%64 = phi i32 [ %61, %56 ], [ %76, %62 ]
%65 = getelementptr inbounds [1023 x i32], [1023 x i32]* %3, i64 0, i64 %63
%66 = load i32, i32* %65
%67 = srem i32 %64, 1023
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds [1023 x i32], [1023 x i32]* %4, i64 0, i64 %68
%70 = load i32, i32* %69
%71 = mul nsw i32 %70, %66
%72 = sub nsw i32 1, %71
%73 = sdiv i32 %72, 2
%74 = getelementptr inbounds i32, i32* %0, i64 %63
store i32 %73, i32* %74
%75 = add nuw nsw i64 %63, 1
%76 = add nsw i32 %64, 1
%77 = icmp eq i64 %75, 1023
br i1 %77, label %78, label %62
78: ; preds = %62, %2
ret void
}