int quad_interp(float *quads, int nx, int ny, float *out) {
  int i, j, ii, jj, ffi, ffj, qx, qy, nxq, nyq;
  float nine[3][3];
  float *quad;
  double a, b;
  a = 0.5;
  b = 0.25;
  nxq = nx + 2;
  nyq = ny + 2;
  for (i = 0; i < nx; i++) {
    qx = 2 * i / nx;
    ffi = 2 * i - qx * nx;
    for (j = 0; j < ny; j++) {
      qy = 2 * j / ny;
      quad = quads + (2 * qy + qx) * nxq;
      ffj = 2 * j - qy * ny;
      for (ii = 0; ii < 3; ii++)
        for (jj = 0; jj < 3; jj++) {
          nine[ii][jj] = 0.25 * (quad[(ffj + jj) * nxq + (ffi + ii)] +
                                 quad[(ffj + jj + 1) * nxq + (ffi + ii)] +
                                 quad[(ffj + jj) * nxq + (ffi + ii + 1)] +
                                 quad[(ffj + jj + 1) * nxq + (ffi + ii + 1)]);
        }
      out[j * nx + i] =
          (1.0 - a - b) * nine[1][1] +
          0.25 * a * (nine[0][1] + nine[1][0] + nine[1][2] + nine[2][1]) +
          0.25 * b * (nine[0][0] + nine[0][2] + nine[2][0] + nine[2][2]);
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<quad_interp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
movsd  0xeea(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0xed5(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0xc(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1375 <quad_interp+0x275>
mov    -0x1c(%rbp),%eax
shl    $0x1,%eax
cltd
idivl  -0xc(%rbp)
mov    %eax,-0x34(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1,%eax
mov    -0x34(%rbp),%ecx
imul   -0xc(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1362 <quad_interp+0x262>
mov    -0x20(%rbp),%eax
shl    $0x1,%eax
cltd
idivl  -0x10(%rbp)
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
add    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x1,%eax
mov    -0x38(%rbp),%ecx
imul   -0x10(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x3,-0x24(%rbp)
jge    12bb <quad_interp+0x1bb>
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    12a8 <quad_interp+0x1a8>
mov    -0x78(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
add    -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x78(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
add    -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x78(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
add    -0x24(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x78(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
add    -0x24(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd86(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0x24(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11e0 <quad_interp+0xe0>
jmp    12ad <quad_interp+0x1ad>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11cf <quad_interp+0xcf>
movsd  0xd4d(%rip),%xmm1
subsd  -0x80(%rbp),%xmm1
subsd  -0x88(%rbp),%xmm1
ff
movss  -0x60(%rbp),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xd1f(%rip),%xmm0
mulsd  -0x80(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm3
addss  -0x64(%rbp),%xmm3
addss  -0x5c(%rbp),%xmm3
addss  -0x54(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xcee(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movss  -0x70(%rbp),%xmm2
addss  -0x68(%rbp),%xmm2
addss  -0x58(%rbp),%xmm2
addss  -0x50(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    117e <quad_interp+0x7e>
jmp    1367 <quad_interp+0x267>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    114c <quad_interp+0x4c>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<quad_interp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rcx,-0x48(%rsp)
test   %esi,%esi
jle    148e <quad_interp+0x38e>
mov    %edx,%r12d
lea    0x2(%rsi),%r10d
mov    %esi,%eax
mov    %edx,%r9d
movss  -0x80(%rsp),%xmm12
movss  -0x7c(%rsp),%xmm11
movss  -0x78(%rsp),%xmm13
movss  -0x74(%rsp),%xmm15
movss  -0x70(%rsp),%xmm7
movss  -0x6c(%rsp),%xmm2
movss  -0x68(%rsp),%xmm0
movss  -0x64(%rsp),%xmm3
movss  -0x60(%rsp),%xmm5
mov    %rax,-0x38(%rsp)
lea    0x0(,%rax,4),%r15
add    %r9,%r9
xor    %eax,%eax
movss  0xe87(%rip),%xmm14
movsd  0xe86(%rip),%xmm10
mov    %rsi,-0x30(%rsp)
mov    %r10d,-0x54(%rsp)
mov    %r9,-0x18(%rsp)
mov    %r15,-0x20(%rsp)
jmp    11bf <quad_interp+0xbf>
nopl   0x0(%rax,%rax,1)
mov    -0x28(%rsp),%rax
add    $0x1,%rax
addq   $0x4,-0x48(%rsp)
cmp    -0x38(%rsp),%rax
mov    -0x30(%rsp),%rsi
je     1454 <quad_interp+0x354>
mov    %rax,-0x28(%rsp)
add    %eax,%eax
cltd
idiv   %esi
mov    %rdx,-0x40(%rsp)
test   %r12d,%r12d
jle    11a0 <quad_interp+0xa0>
mov    -0x40(%rsp),%rdx
lea    0x1(%rdx),%ecx
mov    %rcx,(%rsp)
lea    0x2(%rdx),%ecx
mov    %rcx,-0x8(%rsp)
lea    0x3(%rdx),%ecx
mov    %ecx,-0x50(%rsp)
mov    -0x48(%rsp),%r14
xor    %r11d,%r11d
mov    %rax,-0x10(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %r11d,%eax
cltd
idiv   %r12d
mov    %edx,%r9d
imul   %r10d,%r9d
lea    0x1(%rdx),%r15d
mov    -0x10(%rsp),%rcx
lea    (%rcx,%rax,2),%esi
imul   %r10d,%r15d
lea    0x2(%rdx),%eax
imul   %r10d,%eax
imul   %r10d,%esi
add    $0x3,%edx
imul   %r10d,%edx
mov    -0x40(%rsp),%r10
lea    (%r9,%r10,1),%ebx
movslq %esi,%rsi
movslq %ebx,%rbx
lea    (%r15,%r10,1),%ebp
movslq %ebp,%rbp
lea    (%rdi,%rsi,4),%rsi
movss  (%rsi,%rbp,4),%xmm11
movss  (%rsi,%rbx,4),%xmm12
mov    (%rsp),%r13
lea    (%r9,%r13,1),%r8d
addss  %xmm11,%xmm12
lea    (%rax,%r10,1),%ebx
movslq %ebx,%rbx
movss  (%rsi,%rbx,4),%xmm13
addss  %xmm13,%xmm11
lea    (%rdx,%r10,1),%ebx
movslq %ebx,%rbx
addss  (%rsi,%rbx,4),%xmm13
movslq %r8d,%rbp
lea    (%r15,%r13,1),%ebx
movslq %ebx,%rbx
movss  (%rsi,%rbx,4),%xmm1
movss  (%rsi,%rbx,4),%xmm7
lea    (%rax,%r13,1),%ebx
addss  (%rsi,%rbp,4),%xmm12
movslq %ebx,%rbx
movss  (%rsi,%rbp,4),%xmm15
lea    (%rdx,%r13,1),%ebp
movss  (%rsi,%rbx,4),%xmm6
movslq %ebp,%rbp
addss  %xmm7,%xmm15
movss  (%rsi,%rbx,4),%xmm2
addss  %xmm6,%xmm13
mov    -0x8(%rsp),%rcx
lea    (%r9,%rcx,1),%ebx
movslq %ebx,%rbx
addss  (%rsi,%rbp,4),%xmm13
addss  %xmm2,%xmm7
addss  (%rsi,%rbp,4),%xmm2
lea    (%r15,%rcx,1),%ebp
movslq %ebp,%rbp
movss  (%rsi,%rbp,4),%xmm0
movss  %xmm0,-0x4c(%rsp)
addss  (%rsi,%rbx,4),%xmm15
movss  (%rsi,%rbp,4),%xmm3
movss  (%rsi,%rbx,4),%xmm0
mov    -0x54(%rsp),%r10d
mov    -0x50(%rsp),%ebx
add    %ebx,%r9d
addss  %xmm3,%xmm0
movslq %r9d,%rbp
mov    -0x18(%rsp),%r9
addss  (%rsi,%rbp,4),%xmm0
add    %ebx,%r15d
movslq %r15d,%rbp
mov    -0x20(%rsp),%r15
movss  (%rsi,%rbp,4),%xmm8
lea    (%rax,%rcx,1),%ebp
movslq %ebp,%rbp
movss  (%rsi,%rbp,4),%xmm9
movss  (%rsi,%rbp,4),%xmm5
lea    (%rdx,%rcx,1),%ebp
addss  %xmm9,%xmm2
movslq %ebp,%rbp
addss  %xmm5,%xmm3
addss  (%rsi,%rbp,4),%xmm2
addss  (%rsi,%rbp,4),%xmm5
add    %ebx,%eax
cltq
movapd %xmm10,%xmm4
movss  (%rsi,%rax,4),%xmm10
add    %ebx,%edx
movslq %edx,%rax
addss  %xmm10,%xmm5
addss  (%rsi,%rax,4),%xmm5
addss  %xmm1,%xmm11
addss  %xmm1,%xmm12
addss  %xmm6,%xmm11
movss  -0x4c(%rsp),%xmm1
addss  %xmm1,%xmm15
addss  %xmm1,%xmm7
mulss  %xmm14,%xmm12
mulss  %xmm14,%xmm11
mulss  %xmm14,%xmm15
addss  %xmm9,%xmm7
mulss  %xmm14,%xmm13
mulss  %xmm14,%xmm7
addss  %xmm8,%xmm0
mulss  %xmm14,%xmm0
mulss  %xmm14,%xmm2
addss  %xmm8,%xmm3
addss  %xmm10,%xmm3
movapd %xmm4,%xmm10
mulss  %xmm14,%xmm3
mulss  %xmm14,%xmm5
xorps  %xmm4,%xmm4
cvtss2sd %xmm7,%xmm4
movaps %xmm11,%xmm6
addss  %xmm15,%xmm6
addss  %xmm2,%xmm6
addss  %xmm3,%xmm6
xorps  %xmm8,%xmm8
cvtss2sd %xmm6,%xmm8
mulsd  0xc0c(%rip),%xmm4
movaps %xmm12,%xmm6
addss  %xmm13,%xmm6
mulsd  %xmm10,%xmm8
addss  %xmm0,%xmm6
addss  %xmm5,%xmm6
cvtss2sd %xmm6,%xmm6
addsd  %xmm8,%xmm4
movsd  0xbed(%rip),%xmm1
mulsd  %xmm1,%xmm6
addsd  %xmm4,%xmm6
xorps  %xmm4,%xmm4
cvtsd2ss %xmm6,%xmm4
movss  %xmm4,(%r14)
add    $0x2,%r11
add    %r15,%r14
cmp    %r11,%r9
jne    1200 <quad_interp+0x100>
jmp    11a0 <quad_interp+0xa0>
movss  %xmm12,-0x80(%rsp)
movss  %xmm11,-0x7c(%rsp)
movss  %xmm13,-0x78(%rsp)
movss  %xmm15,-0x74(%rsp)
movss  %xmm7,-0x70(%rsp)
movss  %xmm2,-0x6c(%rsp)
movss  %xmm0,-0x68(%rsp)
movss  %xmm3,-0x64(%rsp)
movss  %xmm5,-0x60(%rsp)
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @quad_interp(float* %0, i32 %1, i32 %2, float* %3) {
%5 = alloca float*
%6 = alloca i32
%7 = alloca i32
%8 = alloca float*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca [3 x [3 x float]]
%20 = alloca float*
%21 = alloca double
%22 = alloca double
store float* %0, float** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store float* %3, float** %8
store double 5.000000e-01, double* %21
store double 2.500000e-01, double* %22
%23 = load i32, i32* %6
%24 = add nsw i32 %23, 2
store i32 %24, i32* %17
%25 = load i32, i32* %7
%26 = add nsw i32 %25, 2
store i32 %26, i32* %18
store i32 0, i32* %9
br label %27
27: ; preds = %210, %4
%28 = load i32, i32* %9
%29 = load i32, i32* %6
%30 = icmp slt i32 %28, %29
br i1 %30, label %31, label %213
31: ; preds = %27
%32 = load i32, i32* %9
%33 = mul nsw i32 2, %32
%34 = load i32, i32* %6
%35 = sdiv i32 %33, %34
store i32 %35, i32* %15
%36 = load i32, i32* %9
%37 = mul nsw i32 2, %36
%38 = load i32, i32* %15
%39 = load i32, i32* %6
%40 = mul nsw i32 %38, %39
%41 = sub nsw i32 %37, %40
store i32 %41, i32* %13
store i32 0, i32* %10
br label %42
42: ; preds = %206, %31
%43 = load i32, i32* %10
%44 = load i32, i32* %7
%45 = icmp slt i32 %43, %44
br i1 %45, label %46, label %209
46: ; preds = %42
%47 = load i32, i32* %10
%48 = mul nsw i32 2, %47
%49 = load i32, i32* %7
%50 = sdiv i32 %48, %49
store i32 %50, i32* %16
%51 = load float*, float** %5
%52 = load i32, i32* %16
%53 = mul nsw i32 2, %52
%54 = load i32, i32* %15
%55 = add nsw i32 %53, %54
%56 = load i32, i32* %17
%57 = mul nsw i32 %55, %56
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds float, float* %51, i64 %58
store float* %59, float** %20
%60 = load i32, i32* %10
%61 = mul nsw i32 2, %60
%62 = load i32, i32* %16
%63 = load i32, i32* %7
%64 = mul nsw i32 %62, %63
%65 = sub nsw i32 %61, %64
store i32 %65, i32* %14
store i32 0, i32* %11
br label %66
66: ; preds = %146, %46
%67 = load i32, i32* %11
%68 = icmp slt i32 %67, 3
br i1 %68, label %69, label %149
69: ; preds = %66
store i32 0, i32* %12
br label %70
70: ; preds = %142, %69
%71 = load i32, i32* %12
%72 = icmp slt i32 %71, 3
br i1 %72, label %73, label %145
73: ; preds = %70
%74 = load float*, float** %20
%75 = load i32, i32* %14
%76 = load i32, i32* %12
%77 = add nsw i32 %75, %76
%78 = load i32, i32* %17
%79 = mul nsw i32 %77, %78
%80 = load i32, i32* %13
%81 = load i32, i32* %11
%82 = add nsw i32 %80, %81
%83 = add nsw i32 %79, %82
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds float, float* %74, i64 %84
%86 = load float, float* %85
%87 = load float*, float** %20
%88 = load i32, i32* %14
%89 = load i32, i32* %12
%90 = add nsw i32 %88, %89
%91 = add nsw i32 %90, 1
%92 = load i32, i32* %17
%93 = mul nsw i32 %91, %92
%94 = load i32, i32* %13
%95 = load i32, i32* %11
%96 = add nsw i32 %94, %95
%97 = add nsw i32 %93, %96
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds float, float* %87, i64 %98
%100 = load float, float* %99
%101 = fadd float %86, %100
%102 = load float*, float** %20
%103 = load i32, i32* %14
%104 = load i32, i32* %12
%105 = add nsw i32 %103, %104
%106 = load i32, i32* %17
%107 = mul nsw i32 %105, %106
%108 = load i32, i32* %13
%109 = load i32, i32* %11
%110 = add nsw i32 %108, %109
%111 = add nsw i32 %110, 1
%112 = add nsw i32 %107, %111
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds float, float* %102, i64 %113
%115 = load float, float* %114
%116 = fadd float %101, %115
%117 = load float*, float** %20
%118 = load i32, i32* %14
%119 = load i32, i32* %12
%120 = add nsw i32 %118, %119
%121 = add nsw i32 %120, 1
%122 = load i32, i32* %17
%123 = mul nsw i32 %121, %122
%124 = load i32, i32* %13
%125 = load i32, i32* %11
%126 = add nsw i32 %124, %125
%127 = add nsw i32 %126, 1
%128 = add nsw i32 %123, %127
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds float, float* %117, i64 %129
%131 = load float, float* %130
%132 = fadd float %116, %131
%133 = fpext float %132 to double
%134 = fmul double 2.500000e-01, %133
%135 = fptrunc double %134 to float
%136 = load i32, i32* %11
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %19, i64 0, i64 %137
%139 = load i32, i32* %12
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds [3 x float], [3 x float]* %138, i64 0, i64 %140
store float %135, float* %141
br label %142
142: ; preds = %73
%143 = load i32, i32* %12
%144 = add nsw i32 %143, 1
store i32 %144, i32* %12
br label %70
145: ; preds = %70
br label %146
146: ; preds = %145
%147 = load i32, i32* %11
%148 = add nsw i32 %147, 1
store i32 %148, i32* %11
br label %66
149: ; preds = %66
%150 = load double, double* %21
%151 = fsub double 1.000000e+00, %150
%152 = load double, double* %22
%153 = fsub double %151, %152
%154 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %19, i64 0, i64 1
%155 = getelementptr inbounds [3 x float], [3 x float]* %154, i64 0, i64 1
%156 = load float, float* %155
%157 = fpext float %156 to double
%158 = load double, double* %21
%159 = fmul double 2.500000e-01, %158
%160 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %19, i64 0, i64 0
%161 = getelementptr inbounds [3 x float], [3 x float]* %160, i64 0, i64 1
%162 = load float, float* %161
%163 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %19, i64 0, i64 1
%164 = getelementptr inbounds [3 x float], [3 x float]* %163, i64 0, i64 0
%165 = load float, float* %164
%166 = fadd float %162, %165
%167 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %19, i64 0, i64 1
%168 = getelementptr inbounds [3 x float], [3 x float]* %167, i64 0, i64 2
%169 = load float, float* %168
%170 = fadd float %166, %169
%171 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %19, i64 0, i64 2
%172 = getelementptr inbounds [3 x float], [3 x float]* %171, i64 0, i64 1
%173 = load float, float* %172
%174 = fadd float %170, %173
%175 = fpext float %174 to double
%176 = fmul double %159, %175
%177 = call double @llvm.fmuladd.f64(double %153, double %157, double %176)
%178 = load double, double* %22
%179 = fmul double 2.500000e-01, %178
%180 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %19, i64 0, i64 0
%181 = getelementptr inbounds [3 x float], [3 x float]* %180, i64 0, i64 0
%182 = load float, float* %181
%183 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %19, i64 0, i64 0
%184 = getelementptr inbounds [3 x float], [3 x float]* %183, i64 0, i64 2
%185 = load float, float* %184
%186 = fadd float %182, %185
%187 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %19, i64 0, i64 2
%188 = getelementptr inbounds [3 x float], [3 x float]* %187, i64 0, i64 0
%189 = load float, float* %188
%190 = fadd float %186, %189
%191 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %19, i64 0, i64 2
%192 = getelementptr inbounds [3 x float], [3 x float]* %191, i64 0, i64 2
%193 = load float, float* %192
%194 = fadd float %190, %193
%195 = fpext float %194 to double
%196 = call double @llvm.fmuladd.f64(double %179, double %195, double %177)
%197 = fptrunc double %196 to float
%198 = load float*, float** %8
%199 = load i32, i32* %10
%200 = load i32, i32* %6
%201 = mul nsw i32 %199, %200
%202 = load i32, i32* %9
%203 = add nsw i32 %201, %202
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds float, float* %198, i64 %204
store float %197, float* %205
br label %206
206: ; preds = %149
%207 = load i32, i32* %10
%208 = add nsw i32 %207, 1
store i32 %208, i32* %10
br label %42
209: ; preds = %42
br label %210
210: ; preds = %209
%211 = load i32, i32* %9
%212 = add nsw i32 %211, 1
store i32 %212, i32* %9
br label %27
213: ; preds = %27
ret i32 0
}

LLVM IR (-O2):
define i32 @quad_interp(float* nocapture %0, i32 %1, i32 %2, float* nocapture writeonly %3) {
%5 = alloca [3 x [3 x float]]
%6 = bitcast [3 x [3 x float]]* %5 to i8*
%7 = add nsw i32 %1, 2
%8 = icmp sgt i32 %1, 0
br i1 %8, label %9, label %262
9: ; preds = %4
%10 = icmp sgt i32 %2, 0
%11 = zext i32 %1 to i64
%12 = zext i32 %1 to i64
%13 = zext i32 %2 to i64
%14 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %5, i64 0, i64 0, i64 0
%15 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %5, i64 0, i64 0, i64 1
%16 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %5, i64 0, i64 0, i64 2
%17 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %5, i64 0, i64 1, i64 0
%18 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %5, i64 0, i64 1, i64 1
%19 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %5, i64 0, i64 1, i64 2
%20 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %5, i64 0, i64 2, i64 0
%21 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %5, i64 0, i64 2, i64 1
%22 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %5, i64 0, i64 2, i64 2
%23 = load float, float* %14
%24 = load float, float* %15
%25 = load float, float* %16
%26 = load float, float* %17
%27 = load float, float* %18
%28 = load float, float* %19
%29 = load float, float* %20
%30 = load float, float* %21
%31 = load float, float* %22
br label %32
32: ; preds = %9, %249
%33 = phi float [ %31, %9 ], [ %250, %249 ]
%34 = phi float [ %30, %9 ], [ %251, %249 ]
%35 = phi float [ %29, %9 ], [ %252, %249 ]
%36 = phi float [ %28, %9 ], [ %253, %249 ]
%37 = phi float [ %27, %9 ], [ %254, %249 ]
%38 = phi float [ %26, %9 ], [ %255, %249 ]
%39 = phi float [ %25, %9 ], [ %256, %249 ]
%40 = phi float [ %24, %9 ], [ %257, %249 ]
%41 = phi float [ %23, %9 ], [ %258, %249 ]
%42 = phi i64 [ 0, %9 ], [ %259, %249 ]
%43 = trunc i64 %42 to i32
%44 = shl i32 %43, 1
%45 = sdiv i32 %44, %1
%46 = mul nsw i32 %45, %1
%47 = srem i32 %44, %1
br i1 %10, label %48, label %249
48: ; preds = %32
%49 = add nsw i32 %47, 1
%50 = add nsw i32 %47, 1
%51 = add nsw i32 %47, 2
%52 = add nsw i32 %47, 2
%53 = add nsw i32 %47, 3
br label %54
54: ; preds = %48, %54
%55 = phi i64 [ %247, %54 ], [ 0, %48 ]
%56 = trunc i64 %55 to i32
%57 = shl i32 %56, 1
%58 = sdiv i32 %57, %2
%59 = shl nsw i32 %58, 1
%60 = add nsw i32 %59, %45
%61 = mul nsw i32 %60, %7
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds float, float* %0, i64 %62
%64 = mul nsw i32 %58, %2
%65 = srem i32 %57, %2
%66 = mul nsw i32 %65, %7
%67 = add nsw i32 %65, 1
%68 = mul nsw i32 %67, %7
%69 = add nsw i32 %65, 2
%70 = mul nsw i32 %69, %7
%71 = add nsw i32 %65, 2
%72 = mul nsw i32 %71, %7
%73 = add nsw i32 %65, 3
%74 = mul nsw i32 %73, %7
%75 = add nsw i32 %66, %47
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds float, float* %63, i64 %76
%78 = load float, float* %77
%79 = add nsw i32 %68, %47
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds float, float* %63, i64 %80
%82 = load float, float* %81
%83 = fadd float %78, %82
%84 = add nsw i32 %66, %49
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds float, float* %63, i64 %85
%87 = load float, float* %86
%88 = fadd float %83, %87
%89 = add nsw i32 %68, %49
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds float, float* %63, i64 %90
%92 = load float, float* %91
%93 = fadd float %88, %92
%94 = fmul float %93, 2.500000e-01
%95 = add nsw i32 %70, %47
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds float, float* %63, i64 %96
%98 = load float, float* %97
%99 = fadd float %82, %98
%100 = fadd float %99, %92
%101 = add nsw i32 %70, %49
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds float, float* %63, i64 %102
%104 = load float, float* %103
%105 = fadd float %100, %104
%106 = fmul float %105, 2.500000e-01
%107 = add nsw i32 %72, %47
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds float, float* %63, i64 %108
%110 = load float, float* %109
%111 = add nsw i32 %74, %47
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds float, float* %63, i64 %112
%114 = load float, float* %113
%115 = fadd float %110, %114
%116 = add nsw i32 %72, %49
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds float, float* %63, i64 %117
%119 = load float, float* %118
%120 = fadd float %115, %119
%121 = add nsw i32 %74, %49
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds float, float* %63, i64 %122
%124 = load float, float* %123
%125 = fadd float %120, %124
%126 = fmul float %125, 2.500000e-01
%127 = add nsw i32 %66, %50
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds float, float* %63, i64 %128
%130 = load float, float* %129
%131 = add nsw i32 %68, %50
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds float, float* %63, i64 %132
%134 = load float, float* %133
%135 = fadd float %130, %134
%136 = add nsw i32 %66, %51
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds float, float* %63, i64 %137
%139 = load float, float* %138
%140 = fadd float %135, %139
%141 = add nsw i32 %68, %51
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds float, float* %63, i64 %142
%144 = load float, float* %143
%145 = fadd float %140, %144
%146 = fmul float %145, 2.500000e-01
%147 = add nsw i32 %70, %50
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds float, float* %63, i64 %148
%150 = load float, float* %149
%151 = fadd float %134, %150
%152 = fadd float %151, %144
%153 = add nsw i32 %70, %51
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds float, float* %63, i64 %154
%156 = load float, float* %155
%157 = fadd float %152, %156
%158 = fmul float %157, 2.500000e-01
%159 = add nsw i32 %72, %50
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds float, float* %63, i64 %160
%162 = load float, float* %161
%163 = add nsw i32 %74, %50
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds float, float* %63, i64 %164
%166 = load float, float* %165
%167 = fadd float %162, %166
%168 = add nsw i32 %72, %51
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds float, float* %63, i64 %169
%171 = load float, float* %170
%172 = fadd float %167, %171
%173 = add nsw i32 %74, %51
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds float, float* %63, i64 %174
%176 = load float, float* %175
%177 = fadd float %172, %176
%178 = fmul float %177, 2.500000e-01
%179 = add nsw i32 %66, %52
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds float, float* %63, i64 %180
%182 = load float, float* %181
%183 = add nsw i32 %68, %52
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds float, float* %63, i64 %184
%186 = load float, float* %185
%187 = fadd float %182, %186
%188 = add nsw i32 %66, %53
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds float, float* %63, i64 %189
%191 = load float, float* %190
%192 = fadd float %187, %191
%193 = add nsw i32 %68, %53
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds float, float* %63, i64 %194
%196 = load float, float* %195
%197 = fadd float %192, %196
%198 = fmul float %197, 2.500000e-01
%199 = add nsw i32 %70, %52
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds float, float* %63, i64 %200
%202 = load float, float* %201
%203 = fadd float %186, %202
%204 = fadd float %203, %196
%205 = add nsw i32 %70, %53
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds float, float* %63, i64 %206
%208 = load float, float* %207
%209 = fadd float %204, %208
%210 = fmul float %209, 2.500000e-01
%211 = add nsw i32 %72, %52
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds float, float* %63, i64 %212
%214 = load float, float* %213
%215 = add nsw i32 %74, %52
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds float, float* %63, i64 %216
%218 = load float, float* %217
%219 = fadd float %214, %218
%220 = add nsw i32 %72, %53
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds float, float* %63, i64 %221
%223 = load float, float* %222
%224 = fadd float %219, %223
%225 = add nsw i32 %74, %53
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds float, float* %63, i64 %226
%228 = load float, float* %227
%229 = fadd float %224, %228
%230 = fmul float %229, 2.500000e-01
%231 = fpext float %158 to double
%232 = fadd float %106, %146
%233 = fadd float %232, %178
%234 = fadd float %233, %210
%235 = fpext float %234 to double
%236 = fmul double %235, 1.250000e-01
%237 = tail call double @llvm.fmuladd.f64(double %231, double 2.500000e-01, double %236)
%238 = fadd float %94, %126
%239 = fadd float %238, %198
%240 = fadd float %239, %230
%241 = fpext float %240 to double
%242 = tail call double @llvm.fmuladd.f64(double %241, double 6.250000e-02, double %237)
%243 = fptrunc double %242 to float
%244 = mul nsw i64 %55, %11
%245 = add nuw nsw i64 %244, %42
%246 = getelementptr inbounds float, float* %3, i64 %245
store float %243, float* %246
%247 = add nuw nsw i64 %55, 1
%248 = icmp eq i64 %247, %13
br i1 %248, label %249, label %54
249: ; preds = %54, %32
%250 = phi float [ %33, %32 ], [ %230, %54 ]
%251 = phi float [ %34, %32 ], [ %210, %54 ]
%252 = phi float [ %35, %32 ], [ %198, %54 ]
%253 = phi float [ %36, %32 ], [ %178, %54 ]
%254 = phi float [ %37, %32 ], [ %158, %54 ]
%255 = phi float [ %38, %32 ], [ %146, %54 ]
%256 = phi float [ %39, %32 ], [ %126, %54 ]
%257 = phi float [ %40, %32 ], [ %106, %54 ]
%258 = phi float [ %41, %32 ], [ %94, %54 ]
%259 = add nuw nsw i64 %42, 1
%260 = icmp eq i64 %259, %12
br i1 %260, label %261, label %32
261: ; preds = %249
store float %258, float* %14
store float %257, float* %15
store float %256, float* %16
store float %255, float* %17
store float %254, float* %18
store float %253, float* %19
store float %252, float* %20
store float %251, float* %21
store float %250, float* %22
br label %262
262: ; preds = %261, %4
ret i32 0
}