void acd_2d_4_d(float **uc, float **ucd, float **up, float **upd, float **csq,
                float **csqd, int *s, int *e, float c0, float *c1, float *c2,
                int *lbc, int *rbc) {
  int i0, i1;
  int s0 = s[0];
  int e0 = e[0];
  float lap;
  for (i1 = s[1]; i1 <= e[1]; i1++)
#pragma ivdep
    for (i0 = s0; i0 <= e0; i0++) {
      lap = (c0 * uc[i1][i0] + c1[0] * (uc[i1][i0 + 1] + uc[i1][i0 - 1]) +
             c1[1] * (uc[i1 + 1][i0] + uc[i1 - 1][i0]) +
             c2[0] * (uc[i1][i0 + 2] + uc[i1][i0 - 2]) +
             c2[1] * (uc[i1 + 2][i0] + uc[i1 - 2][i0]));
      upd[i1][i0] = 2.0 * ucd[i1][i0] - upd[i1][i0] + csqd[i1][i0] * lap +
                    csq[i1][i0] * (c0 * ucd[i1][i0] +
                                   c1[0] * (ucd[i1][i0 + 1] + ucd[i1][i0 - 1]) +
                                   c1[1] * (ucd[i1 + 1][i0] + ucd[i1 - 1][i0]) +
                                   c2[0] * (ucd[i1][i0 + 2] + ucd[i1][i0 - 2]) +
                                   c2[1] * (ucd[i1 + 2][i0] + ucd[i1 - 2][i0]));
      up[i1][i0] = 2.0 * uc[i1][i0] - up[i1][i0] + csq[i1][i0] * lap;
    }
  if (lbc[1])
#pragma ivdep
    for (i0 = s0; i0 <= e0; i0++) {
      upd[s[1] - 2][i0] = -upd[s[1]][i0];
      up[s[1] - 2][i0] = -up[s[1]][i0];
    }
  if (rbc[1])
#pragma ivdep
    for (i0 = s0; i0 <= e0; i0++) {
      upd[e[1] + 2][i0] = -upd[e[1]][i0];
      up[e[1] + 2][i0] = -up[e[1]][i0];
    }
  if (lbc[0])
#pragma ivdep
    for (i1 = s[1]; i1 <= e[1]; ++i1) {
      upd[i1][s[0] - 2] = -upd[i1][s[0]];
      up[i1][s[0] - 2] = -up[i1][s[0]];
    }
  if (rbc[0])
#pragma ivdep
    for (i1 = s[1]; i1 <= e[1]; ++i1) {
      upd[i1][e[0] + 2] = -upd[i1][e[0]];
      up[i1][e[0] + 2] = -up[i1][e[0]];
    }
}


x86 assembly (clang, -O0):
<acd_2d_4_d>:
push   %rbp
mov    %rsp,%rbp
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movss  %xmm0,-0x34(%rbp)
mov    0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x40(%rbp)
mov    0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
mov    0x10(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x18(%rbp),%rcx
cmp    0x4(%rcx),%eax
jg     1536 <acd_2d_4_d+0x436>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     1523 <acd_2d_4_d+0x423>
movss  -0x34(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x48(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x34(%rbp),%xmm3
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mov    0x20(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
mulss  %xmm5,%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
mov    0x20(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mov    0x28(%rbp),%rax
movss  (%rax),%xmm3
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
mov    0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x48(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    116b <acd_2d_4_d+0x6b>
jmp    1528 <acd_2d_4_d+0x428>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1155 <acd_2d_4_d+0x55>
mov    0x30(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     15f1 <acd_2d_4_d+0x4f1>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     15ec <acd_2d_4_d+0x4ec>
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    154a <acd_2d_4_d+0x44a>
jmp    15f1 <acd_2d_4_d+0x4f1>
mov    0x38(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     16ac <acd_2d_4_d+0x5ac>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     16a7 <acd_2d_4_d+0x5a7>
mov    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1605 <acd_2d_4_d+0x505>
jmp    16ac <acd_2d_4_d+0x5ac>
mov    0x30(%rbp),%rax
cmpl   $0x0,(%rax)
je     176a <acd_2d_4_d+0x66a>
mov    0x10(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x18(%rbp),%rcx
cmp    0x4(%rcx),%eax
jg     1765 <acd_2d_4_d+0x665>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    16c3 <acd_2d_4_d+0x5c3>
jmp    176a <acd_2d_4_d+0x66a>
mov    0x38(%rbp),%rax
cmpl   $0x0,(%rax)
je     1828 <acd_2d_4_d+0x728>
mov    0x10(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x18(%rbp),%rcx
cmp    0x4(%rcx),%eax
jg     1823 <acd_2d_4_d+0x723>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1781 <acd_2d_4_d+0x681>
jmp    1828 <acd_2d_4_d+0x728>
pop    %rbp
ret

x86 assembly (clang, -O2):
<acd_2d_4_d>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x10,%rsp
mov    %r9,-0x8(%rsp)
mov    %r8,-0x10(%rsp)
mov    %rcx,%r13
mov    %rsi,-0x18(%rsp)
mov    %rdi,-0x20(%rsp)
mov    0x50(%rsp),%rax
mov    0x48(%rsp),%rcx
movslq (%rcx),%rsi
mov    %rsi,-0x40(%rsp)
movslq (%rax),%rdi
movslq 0x4(%rcx),%rcx
movslq 0x4(%rax),%rax
mov    %rcx,-0x68(%rsp)
mov    %rax,-0x78(%rsp)
cmp    %ecx,%eax
mov    %rdx,-0x70(%rsp)
mov    %rdi,-0x60(%rsp)
mov    %rsi,-0x80(%rsp)
mov    %r13,-0x38(%rsp)
jl     13eb <acd_2d_4_d+0x2eb>
mov    -0x78(%rsp),%rax
add    $0x1,%eax
mov    %edi,%ecx
sub    -0x40(%rsp),%ecx
add    $0x1,%ecx
mov    -0x68(%rsp),%rbp
mov    %eax,-0x24(%rsp)
mov    %rcx,0x8(%rsp)
jmp    119f <acd_2d_4_d+0x9f>
nopl   0x0(%rax)
add    $0x1,%rbp
mov    %rbp,%rbx
cmp    %ebx,%eax
je     13eb <acd_2d_4_d+0x2eb>
cmp    %esi,%edi
jl     1190 <acd_2d_4_d+0x90>
lea    0x0(,%rsi,4),%r15
mov    -0x20(%rsp),%rax
mov    (%rax,%rbp,8),%r11
add    %r15,%r11
mov    -0x18(%rsp),%rbx
mov    (%rbx,%rbp,8),%r10
add    %r15,%r10
mov    0x8(%rax,%rbp,8),%rsi
add    %r15,%rsi
mov    %rsi,-0x48(%rsp)
mov    -0x8(%rax,%rbp,8),%rsi
add    %r15,%rsi
mov    %rsi,-0x50(%rsp)
mov    0x10(%rax,%rbp,8),%rsi
add    %r15,%rsi
mov    %rsi,-0x58(%rsp)
mov    -0x10(%rax,%rbp,8),%rax
add    %r15,%rax
mov    %rax,-0x30(%rsp)
mov    0x0(%r13,%rbp,8),%r9
add    %r15,%r9
mov    -0x8(%rsp),%rax
mov    (%rax,%rbp,8),%r14
add    %r15,%r14
mov    -0x10(%rsp),%rax
mov    (%rax,%rbp,8),%r13
add    %r15,%r13
mov    0x8(%rbx,%rbp,8),%rax
add    %r15,%rax
mov    -0x8(%rbx,%rbp,8),%rsi
add    %r15,%rsi
mov    0x10(%rbx,%rbp,8),%rdi
add    %r15,%rdi
mov    -0x10(%rbx,%rbp,8),%rbx
add    %r15,%rbx
add    (%rdx,%rbp,8),%r15
lea    0x1(%rbp),%rcx
mov    %rcx,(%rsp)
xor    %r12d,%r12d
mov    0x60(%rsp),%rdx
mov    0x58(%rsp),%rbp
movss  0x4(%r11,%r12,4),%xmm1
movss  0x8(%r11,%r12,4),%xmm6
addss  -0x4(%r11,%r12,4),%xmm1
movss  0x0(%rbp),%xmm4
movss  0x4(%rbp),%xmm8
mulss  %xmm4,%xmm1
movss  (%r11,%r12,4),%xmm3
mulss  %xmm0,%xmm3
mov    -0x48(%rsp),%r8
movss  (%r8,%r12,4),%xmm7
mov    -0x50(%rsp),%rcx
addss  (%rcx,%r12,4),%xmm7
addss  %xmm1,%xmm3
mulss  %xmm8,%xmm7
addss  -0x8(%r11,%r12,4),%xmm6
addss  %xmm3,%xmm7
movss  (%rdx),%xmm5
movss  0x4(%rdx),%xmm9
mulss  %xmm5,%xmm6
addss  %xmm7,%xmm6
mov    -0x58(%rsp),%rcx
movss  (%rcx,%r12,4),%xmm1
mov    -0x30(%rsp),%rcx
addss  (%rcx,%r12,4),%xmm1
mulss  %xmm9,%xmm1
addss  %xmm6,%xmm1
movss  (%r10,%r12,4),%xmm7
movss  0x4(%r10,%r12,4),%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm7,%xmm3
movss  (%r9,%r12,4),%xmm6
cvtss2sd %xmm6,%xmm6
addsd  %xmm3,%xmm3
subsd  %xmm6,%xmm3
movss  (%r14,%r12,4),%xmm6
mulss  %xmm1,%xmm6
cvtss2sd %xmm6,%xmm6
addsd  %xmm3,%xmm6
addss  -0x4(%r10,%r12,4),%xmm2
mulss  %xmm4,%xmm2
mulss  %xmm0,%xmm7
movss  (%rax,%r12,4),%xmm3
addss  (%rsi,%r12,4),%xmm3
addss  %xmm2,%xmm7
mulss  %xmm8,%xmm3
addss  %xmm7,%xmm3
movss  0x8(%r10,%r12,4),%xmm2
addss  -0x8(%r10,%r12,4),%xmm2
mulss  %xmm5,%xmm2
addss  %xmm3,%xmm2
movss  (%rdi,%r12,4),%xmm3
addss  (%rbx,%r12,4),%xmm3
mulss  %xmm9,%xmm3
addss  %xmm2,%xmm3
mulss  0x0(%r13,%r12,4),%xmm3
xorps  %xmm2,%xmm2
cvtss2sd %xmm3,%xmm2
addsd  %xmm6,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,(%r9,%r12,4)
movss  (%r11,%r12,4),%xmm2
cvtss2sd %xmm2,%xmm2
movss  (%r15,%r12,4),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm2,%xmm2
subsd  %xmm3,%xmm2
mulss  0x0(%r13,%r12,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%r15,%r12,4)
add    $0x1,%r12
cmp    %r12d,0x8(%rsp)
jne    1250 <acd_2d_4_d+0x150>
mov    (%rsp),%rbx
mov    %rbx,%rbp
mov    -0x38(%rsp),%r13
mov    -0x70(%rsp),%rdx
mov    -0x60(%rsp),%rdi
mov    -0x80(%rsp),%rsi
mov    -0x24(%rsp),%eax
cmp    %ebx,%eax
jne    119f <acd_2d_4_d+0x9f>
mov    0x68(%rsp),%rax
cmpl   $0x0,0x4(%rax)
je     1647 <acd_2d_4_d+0x547>
cmp    -0x40(%rsp),%edi
jl     1647 <acd_2d_4_d+0x547>
mov    -0x68(%rsp),%rcx
mov    0x0(%r13,%rcx,8),%r11
mov    -0x10(%r13,%rcx,8),%r14
mov    -0x70(%rsp),%rax
mov    (%rax,%rcx,8),%r15
mov    -0x10(%rax,%rcx,8),%rbp
mov    %edi,%r9d
mov    -0x80(%rsp),%r10
sub    %r10d,%r9d
cmp    $0x7,%r9d
jae    1453 <acd_2d_4_d+0x353>
lea    0x1(%rdi),%ebx
mov    %ebx,%eax
sub    %r10d,%eax
test   $0x1,%al
jne    15bc <acd_2d_4_d+0x4bc>
mov    %r10,%rcx
cmp    %r10d,%edi
jne    15ee <acd_2d_4_d+0x4ee>
jmp    1647 <acd_2d_4_d+0x547>
mov    -0x80(%rsp),%r10
lea    (%r14,%r10,4),%rax
mov    %edi,%ecx
sub    %r10d,%ecx
add    %r10,%rcx
lea    (%r14,%rcx,4),%rsi
add    $0x4,%rsi
lea    0x0(%rbp,%r10,4),%rdi
lea    0x4(%rbp,%rcx,4),%rbx
lea    (%r11,%r10,4),%r8
lea    (%r11,%rcx,4),%rdx
add    $0x4,%rdx
lea    (%r15,%rcx,4),%r13
add    $0x4,%r13
cmp    %rbx,%rax
setb   -0x48(%rsp)
cmp    %rsi,%rdi
setb   -0x50(%rsp)
cmp    %rdx,%rax
setb   %r12b
cmp    %rsi,%r8
setb   -0x58(%rsp)
cmp    %r13,%rax
lea    (%r15,%r10,4),%rax
setb   %cl
cmp    %rsi,%rax
setb   -0x30(%rsp)
cmp    %rdx,%rdi
setb   %sil
cmp    %rbx,%r8
setb   %r8b
cmp    %r13,%rdi
mov    -0x60(%rsp),%rdi
mov    -0x38(%rsp),%r13
setb   %dl
cmp    %rbx,%rax
setb   %bl
mov    -0x50(%rsp),%al
test   %al,-0x48(%rsp)
jne    1432 <acd_2d_4_d+0x332>
mov    -0x80(%rsp),%r10
and    -0x58(%rsp),%r12b
jne    1432 <acd_2d_4_d+0x332>
mov    -0x80(%rsp),%r10
and    -0x30(%rsp),%cl
jne    1432 <acd_2d_4_d+0x332>
mov    -0x80(%rsp),%r10
and    %r8b,%sil
jne    1432 <acd_2d_4_d+0x332>
mov    -0x80(%rsp),%r10
and    %bl,%dl
jne    1432 <acd_2d_4_d+0x332>
add    $0x1,%r9
mov    %r9,%rcx
and    $0xfffffffffffffff8,%rcx
mov    -0x80(%rsp),%rsi
lea    (%rcx,%rsi,1),%r10
lea    (%r11,%rsi,4),%rbx
add    $0x10,%rbx
lea    (%r14,%rsi,4),%rdx
add    $0x10,%rdx
lea    (%r15,%rsi,4),%rax
add    $0x10,%rax
lea    0x10(,%rsi,4),%rsi
add    %rbp,%rsi
xor    %edi,%edi
movaps 0xa99(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movups -0x10(%rbx,%rdi,4),%xmm1
movups (%rbx,%rdi,4),%xmm2
xorps  %xmm0,%xmm1
xorps  %xmm0,%xmm2
movups %xmm1,-0x10(%rdx,%rdi,4)
movups %xmm2,(%rdx,%rdi,4)
movups -0x10(%rax,%rdi,4),%xmm1
movups (%rax,%rdi,4),%xmm2
xorps  %xmm0,%xmm1
xorps  %xmm0,%xmm2
movups %xmm1,-0x10(%rsi,%rdi,4)
movups %xmm2,(%rsi,%rdi,4)
add    $0x8,%rdi
cmp    %rdi,%rcx
jne    1570 <acd_2d_4_d+0x470>
cmp    %rcx,%r9
mov    -0x60(%rsp),%rdi
jne    1432 <acd_2d_4_d+0x332>
jmp    1647 <acd_2d_4_d+0x547>
movss  (%r11,%r10,4),%xmm0
movaps 0xa37(%rip),%xmm1
xorps  %xmm1,%xmm0
movss  %xmm0,(%r14,%r10,4)
movss  (%r15,%r10,4),%xmm0
xorps  %xmm1,%xmm0
movss  %xmm0,0x0(%rbp,%r10,4)
mov    %r10,%rcx
add    $0x1,%rcx
cmp    %r10d,%edi
je     1647 <acd_2d_4_d+0x547>
mov    %ebx,%edx
movaps 0xa09(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movss  (%r11,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%r14,%rcx,4)
movss  (%r15,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x0(%rbp,%rcx,4)
movss  0x4(%r11,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x4(%r14,%rcx,4)
movss  0x4(%r15,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x4(%rbp,%rcx,4)
add    $0x2,%rcx
cmp    %ecx,%edx
jne    1600 <acd_2d_4_d+0x500>
mov    0x70(%rsp),%r12
cmpl   $0x0,0x4(%r12)
mov    -0x70(%rsp),%r15
mov    -0x68(%rsp),%rbp
mov    -0x80(%rsp),%rbx
je     1898 <acd_2d_4_d+0x798>
cmp    %ebx,%edi
jl     1898 <acd_2d_4_d+0x798>
mov    -0x78(%rsp),%rax
mov    0x0(%r13,%rax,8),%r10
mov    0x10(%r13,%rax,8),%r11
mov    (%r15,%rax,8),%r14
mov    0x10(%r15,%rax,8),%r8
mov    %edi,%r9d
sub    %ebx,%r9d
cmp    $0x7,%r9d
jae    16b7 <acd_2d_4_d+0x5b7>
lea    0x1(%rdi),%edx
mov    %edx,%eax
mov    -0x40(%rsp),%rsi
sub    %esi,%eax
test   $0x1,%al
jne    1812 <acd_2d_4_d+0x712>
mov    %rsi,%rcx
cmp    %esi,%edi
jne    1842 <acd_2d_4_d+0x742>
jmp    1898 <acd_2d_4_d+0x798>
lea    (%r11,%rbx,4),%rcx
mov    %edi,%eax
sub    %ebx,%eax
add    %rbx,%rax
lea    (%r11,%rax,4),%rdx
add    $0x4,%rdx
lea    (%r8,%rbx,4),%rsi
lea    0x4(%r8,%rax,4),%rbp
mov    %rbx,%r13
lea    (%r10,%rbx,4),%r15
lea    (%r10,%rax,4),%rdi
add    $0x4,%rdi
lea    (%r14,%rax,4),%rax
add    $0x4,%rax
cmp    %rbp,%rcx
setb   -0x48(%rsp)
cmp    %rdx,%rsi
setb   %bl
cmp    %rdi,%rcx
setb   %r12b
cmp    %rdx,%r15
setb   -0x50(%rsp)
cmp    %rax,%rcx
lea    (%r14,%r13,4),%r13
setb   %cl
cmp    %rdx,%r13
setb   -0x58(%rsp)
cmp    %rdi,%rsi
setb   %dl
cmp    %rbp,%r15
setb   %r15b
cmp    %rax,%rsi
setb   %sil
cmp    %rbp,%r13
setb   %al
test   %bl,-0x48(%rsp)
jne    1a53 <acd_2d_4_d+0x953>
and    -0x50(%rsp),%r12b
mov    -0x38(%rsp),%r13
mov    -0x60(%rsp),%rdi
mov    -0x68(%rsp),%rbp
jne    1a4c <acd_2d_4_d+0x94c>
and    -0x58(%rsp),%cl
jne    1a4c <acd_2d_4_d+0x94c>
and    %r15b,%dl
mov    -0x70(%rsp),%r15
mov    0x70(%rsp),%r12
jne    1a42 <acd_2d_4_d+0x942>
and    %al,%sil
mov    -0x80(%rsp),%rbx
jne    1693 <acd_2d_4_d+0x593>
add    $0x1,%r9
mov    %r9,%rdx
and    $0xfffffffffffffff8,%rdx
lea    (%rdx,%rbx,1),%rax
mov    %rax,-0x40(%rsp)
lea    (%r10,%rbx,4),%rbp
add    $0x10,%rbp
lea    (%r11,%rbx,4),%rcx
add    $0x10,%rcx
lea    (%r14,%rbx,4),%rdi
add    $0x10,%rdi
lea    (%r8,%rbx,4),%rsi
add    $0x10,%rsi
xor    %eax,%eax
movaps 0x841(%rip),%xmm0
nop
movups -0x10(%rbp,%rax,4),%xmm1
movups 0x0(%rbp,%rax,4),%xmm2
xorps  %xmm0,%xmm1
xorps  %xmm0,%xmm2
movups %xmm1,-0x10(%rcx,%rax,4)
movups %xmm2,(%rcx,%rax,4)
movups -0x10(%rdi,%rax,4),%xmm1
movups (%rdi,%rax,4),%xmm2
xorps  %xmm0,%xmm1
xorps  %xmm0,%xmm2
movups %xmm1,-0x10(%rsi,%rax,4)
movups %xmm2,(%rsi,%rax,4)
add    $0x8,%rax
cmp    %rax,%rdx
jne    17c0 <acd_2d_4_d+0x6c0>
cmp    %rdx,%r9
mov    -0x60(%rsp),%rdi
mov    -0x68(%rsp),%rbp
jne    1693 <acd_2d_4_d+0x593>
jmp    1898 <acd_2d_4_d+0x798>
movss  (%r10,%rsi,4),%xmm0
movaps 0x7e1(%rip),%xmm1
xorps  %xmm1,%xmm0
movss  %xmm0,(%r11,%rsi,4)
movss  (%r14,%rsi,4),%xmm0
xorps  %xmm1,%xmm0
movss  %xmm0,(%r8,%rsi,4)
mov    %rsi,%rcx
add    $0x1,%rcx
cmp    %esi,%edi
je     1898 <acd_2d_4_d+0x798>
mov    %edx,%edx
movaps 0x7b5(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movss  (%r10,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%r11,%rcx,4)
movss  (%r14,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%r8,%rcx,4)
movss  0x4(%r10,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x4(%r11,%rcx,4)
movss  0x4(%r14,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x4(%r8,%rcx,4)
add    $0x2,%rcx
cmp    %ecx,%edx
jne    1850 <acd_2d_4_d+0x750>
mov    0x68(%rsp),%rax
cmpl   $0x0,(%rax)
je     1963 <acd_2d_4_d+0x863>
cmp    %ebp,-0x78(%rsp)
jl     1963 <acd_2d_4_d+0x863>
mov    -0x78(%rsp),%rax
lea    0x1(%rax),%ecx
mov    %ecx,%edx
sub    %ebp,%edx
mov    %rbp,%rax
test   $0x1,%dl
je     18f4 <acd_2d_4_d+0x7f4>
mov    0x0(%r13,%rbp,8),%rax
movss  (%rax,%rbx,4),%xmm0
movaps 0x72b(%rip),%xmm1
xorps  %xmm1,%xmm0
movss  %xmm0,-0x8(%rax,%rbx,4)
mov    (%r15,%rbp,8),%rax
movss  (%rax,%rbx,4),%xmm0
xorps  %xmm1,%xmm0
movss  %xmm0,-0x8(%rax,%rbx,4)
lea    0x1(%rbp),%rax
cmp    %ebp,-0x78(%rsp)
je     1963 <acd_2d_4_d+0x863>
mov    %ecx,%ecx
movaps 0x6fd(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x0(%r13,%rax,8),%rdx
movss  (%rdx,%rbx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x8(%rdx,%rbx,4)
mov    (%r15,%rax,8),%rdx
movss  (%rdx,%rbx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x8(%rdx,%rbx,4)
mov    0x8(%r13,%rax,8),%rdx
movss  (%rdx,%rbx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x8(%rdx,%rbx,4)
mov    0x8(%r15,%rax,8),%rdx
movss  (%rdx,%rbx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x8(%rdx,%rbx,4)
add    $0x2,%rax
cmp    %eax,%ecx
jne    1910 <acd_2d_4_d+0x810>
cmpl   $0x0,(%r12)
je     1a33 <acd_2d_4_d+0x933>
cmp    %ebp,-0x78(%rsp)
jl     1a33 <acd_2d_4_d+0x933>
mov    -0x78(%rsp),%rax
lea    0x1(%rax),%ecx
mov    %ecx,%eax
sub    %ebp,%eax
test   $0x1,%al
jne    1996 <acd_2d_4_d+0x896>
mov    %rbp,%rax
cmp    %ebp,-0x78(%rsp)
jne    19cf <acd_2d_4_d+0x8cf>
jmp    1a33 <acd_2d_4_d+0x933>
mov    0x0(%r13,%rbp,8),%rax
movss  (%rax,%rdi,4),%xmm0
movaps 0x659(%rip),%xmm1
xorps  %xmm1,%xmm0
movss  %xmm0,0x8(%rax,%rdi,4)
mov    (%r15,%rbp,8),%rax
movss  (%rax,%rdi,4),%xmm0
xorps  %xmm1,%xmm0
movss  %xmm0,0x8(%rax,%rdi,4)
mov    %rbp,%rax
add    $0x1,%rax
cmp    %ebp,-0x78(%rsp)
je     1a33 <acd_2d_4_d+0x933>
mov    %ecx,%ecx
movaps 0x628(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rax,8),%rdx
movss  (%rdx,%rdi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x8(%rdx,%rdi,4)
mov    (%r15,%rax,8),%rdx
movss  (%rdx,%rdi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x8(%rdx,%rdi,4)
mov    0x8(%r13,%rax,8),%rdx
movss  (%rdx,%rdi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x8(%rdx,%rdi,4)
mov    0x8(%r15,%rax,8),%rdx
movss  (%rdx,%rdi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x8(%rdx,%rdi,4)
add    $0x2,%rax
cmp    %eax,%ecx
jne    19e0 <acd_2d_4_d+0x8e0>
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    -0x80(%rsp),%rbx
jmp    1693 <acd_2d_4_d+0x593>
mov    -0x70(%rsp),%r15
jmp    1a67 <acd_2d_4_d+0x967>
mov    -0x38(%rsp),%r13
mov    -0x70(%rsp),%r15
mov    -0x60(%rsp),%rdi
mov    -0x68(%rsp),%rbp
mov    -0x80(%rsp),%rbx
mov    0x70(%rsp),%r12
jmp    1693 <acd_2d_4_d+0x593>

LLVM IR (-O0):
define void @acd_2d_4_d(float** %0, float** %1, float** %2, float** %3, float** %4, float** %5, i32* %6, i32* %7, float %8, float* %9, float* %10, i32* %11, i32* %12) {
%14 = alloca float**
%15 = alloca float**
%16 = alloca float**
%17 = alloca float**
%18 = alloca float**
%19 = alloca float**
%20 = alloca i32*
%21 = alloca i32*
%22 = alloca float
%23 = alloca float*
%24 = alloca float*
%25 = alloca i32*
%26 = alloca i32*
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca float
store float** %0, float*** %14
store float** %1, float*** %15
store float** %2, float*** %16
store float** %3, float*** %17
store float** %4, float*** %18
store float** %5, float*** %19
store i32* %6, i32** %20
store i32* %7, i32** %21
store float %8, float* %22
store float* %9, float** %23
store float* %10, float** %24
store i32* %11, i32** %25
store i32* %12, i32** %26
%32 = load i32*, i32** %20
%33 = getelementptr inbounds i32, i32* %32, i64 0
%34 = load i32, i32* %33
store i32 %34, i32* %29
%35 = load i32*, i32** %21
%36 = getelementptr inbounds i32, i32* %35, i64 0
%37 = load i32, i32* %36
store i32 %37, i32* %30
%38 = load i32*, i32** %20
%39 = getelementptr inbounds i32, i32* %38, i64 1
%40 = load i32, i32* %39
store i32 %40, i32* %28
br label %41
41: ; preds = %380, %13
%42 = load i32, i32* %28
%43 = load i32*, i32** %21
%44 = getelementptr inbounds i32, i32* %43, i64 1
%45 = load i32, i32* %44
%46 = icmp sle i32 %42, %45
br i1 %46, label %47, label %383
47: ; preds = %41
%48 = load i32, i32* %29
store i32 %48, i32* %27
br label %49
49: ; preds = %376, %47
%50 = load i32, i32* %27
%51 = load i32, i32* %30
%52 = icmp sle i32 %50, %51
br i1 %52, label %53, label %379
53: ; preds = %49
%54 = load float, float* %22
%55 = load float**, float*** %14
%56 = load i32, i32* %28
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds float*, float** %55, i64 %57
%59 = load float*, float** %58
%60 = load i32, i32* %27
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds float, float* %59, i64 %61
%63 = load float, float* %62
%64 = load float*, float** %23
%65 = getelementptr inbounds float, float* %64, i64 0
%66 = load float, float* %65
%67 = load float**, float*** %14
%68 = load i32, i32* %28
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds float*, float** %67, i64 %69
%71 = load float*, float** %70
%72 = load i32, i32* %27
%73 = add nsw i32 %72, 1
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds float, float* %71, i64 %74
%76 = load float, float* %75
%77 = load float**, float*** %14
%78 = load i32, i32* %28
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds float*, float** %77, i64 %79
%81 = load float*, float** %80
%82 = load i32, i32* %27
%83 = sub nsw i32 %82, 1
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds float, float* %81, i64 %84
%86 = load float, float* %85
%87 = fadd float %76, %86
%88 = fmul float %66, %87
%89 = call float @llvm.fmuladd.f32(float %54, float %63, float %88)
%90 = load float*, float** %23
%91 = getelementptr inbounds float, float* %90, i64 1
%92 = load float, float* %91
%93 = load float**, float*** %14
%94 = load i32, i32* %28
%95 = add nsw i32 %94, 1
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds float*, float** %93, i64 %96
%98 = load float*, float** %97
%99 = load i32, i32* %27
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds float, float* %98, i64 %100
%102 = load float, float* %101
%103 = load float**, float*** %14
%104 = load i32, i32* %28
%105 = sub nsw i32 %104, 1
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds float*, float** %103, i64 %106
%108 = load float*, float** %107
%109 = load i32, i32* %27
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds float, float* %108, i64 %110
%112 = load float, float* %111
%113 = fadd float %102, %112
%114 = call float @llvm.fmuladd.f32(float %92, float %113, float %89)
%115 = load float*, float** %24
%116 = getelementptr inbounds float, float* %115, i64 0
%117 = load float, float* %116
%118 = load float**, float*** %14
%119 = load i32, i32* %28
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds float*, float** %118, i64 %120
%122 = load float*, float** %121
%123 = load i32, i32* %27
%124 = add nsw i32 %123, 2
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds float, float* %122, i64 %125
%127 = load float, float* %126
%128 = load float**, float*** %14
%129 = load i32, i32* %28
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds float*, float** %128, i64 %130
%132 = load float*, float** %131
%133 = load i32, i32* %27
%134 = sub nsw i32 %133, 2
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds float, float* %132, i64 %135
%137 = load float, float* %136
%138 = fadd float %127, %137
%139 = call float @llvm.fmuladd.f32(float %117, float %138, float %114)
%140 = load float*, float** %24
%141 = getelementptr inbounds float, float* %140, i64 1
%142 = load float, float* %141
%143 = load float**, float*** %14
%144 = load i32, i32* %28
%145 = add nsw i32 %144, 2
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds float*, float** %143, i64 %146
%148 = load float*, float** %147
%149 = load i32, i32* %27
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds float, float* %148, i64 %150
%152 = load float, float* %151
%153 = load float**, float*** %14
%154 = load i32, i32* %28
%155 = sub nsw i32 %154, 2
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds float*, float** %153, i64 %156
%158 = load float*, float** %157
%159 = load i32, i32* %27
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds float, float* %158, i64 %160
%162 = load float, float* %161
%163 = fadd float %152, %162
%164 = call float @llvm.fmuladd.f32(float %142, float %163, float %139)
store float %164, float* %31
%165 = load float**, float*** %15
%166 = load i32, i32* %28
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds float*, float** %165, i64 %167
%169 = load float*, float** %168
%170 = load i32, i32* %27
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds float, float* %169, i64 %171
%173 = load float, float* %172
%174 = fpext float %173 to double
%175 = load float**, float*** %17
%176 = load i32, i32* %28
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds float*, float** %175, i64 %177
%179 = load float*, float** %178
%180 = load i32, i32* %27
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds float, float* %179, i64 %181
%183 = load float, float* %182
%184 = fpext float %183 to double
%185 = fneg double %184
%186 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %174, double %185)
%187 = load float**, float*** %19
%188 = load i32, i32* %28
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds float*, float** %187, i64 %189
%191 = load float*, float** %190
%192 = load i32, i32* %27
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds float, float* %191, i64 %193
%195 = load float, float* %194
%196 = load float, float* %31
%197 = fmul float %195, %196
%198 = fpext float %197 to double
%199 = fadd double %186, %198
%200 = load float**, float*** %18
%201 = load i32, i32* %28
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds float*, float** %200, i64 %202
%204 = load float*, float** %203
%205 = load i32, i32* %27
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds float, float* %204, i64 %206
%208 = load float, float* %207
%209 = load float, float* %22
%210 = load float**, float*** %15
%211 = load i32, i32* %28
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds float*, float** %210, i64 %212
%214 = load float*, float** %213
%215 = load i32, i32* %27
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds float, float* %214, i64 %216
%218 = load float, float* %217
%219 = load float*, float** %23
%220 = getelementptr inbounds float, float* %219, i64 0
%221 = load float, float* %220
%222 = load float**, float*** %15
%223 = load i32, i32* %28
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds float*, float** %222, i64 %224
%226 = load float*, float** %225
%227 = load i32, i32* %27
%228 = add nsw i32 %227, 1
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds float, float* %226, i64 %229
%231 = load float, float* %230
%232 = load float**, float*** %15
%233 = load i32, i32* %28
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds float*, float** %232, i64 %234
%236 = load float*, float** %235
%237 = load i32, i32* %27
%238 = sub nsw i32 %237, 1
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds float, float* %236, i64 %239
%241 = load float, float* %240
%242 = fadd float %231, %241
%243 = fmul float %221, %242
%244 = call float @llvm.fmuladd.f32(float %209, float %218, float %243)
%245 = load float*, float** %23
%246 = getelementptr inbounds float, float* %245, i64 1
%247 = load float, float* %246
%248 = load float**, float*** %15
%249 = load i32, i32* %28
%250 = add nsw i32 %249, 1
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds float*, float** %248, i64 %251
%253 = load float*, float** %252
%254 = load i32, i32* %27
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds float, float* %253, i64 %255
%257 = load float, float* %256
%258 = load float**, float*** %15
%259 = load i32, i32* %28
%260 = sub nsw i32 %259, 1
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds float*, float** %258, i64 %261
%263 = load float*, float** %262
%264 = load i32, i32* %27
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds float, float* %263, i64 %265
%267 = load float, float* %266
%268 = fadd float %257, %267
%269 = call float @llvm.fmuladd.f32(float %247, float %268, float %244)
%270 = load float*, float** %24
%271 = getelementptr inbounds float, float* %270, i64 0
%272 = load float, float* %271
%273 = load float**, float*** %15
%274 = load i32, i32* %28
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds float*, float** %273, i64 %275
%277 = load float*, float** %276
%278 = load i32, i32* %27
%279 = add nsw i32 %278, 2
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds float, float* %277, i64 %280
%282 = load float, float* %281
%283 = load float**, float*** %15
%284 = load i32, i32* %28
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds float*, float** %283, i64 %285
%287 = load float*, float** %286
%288 = load i32, i32* %27
%289 = sub nsw i32 %288, 2
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds float, float* %287, i64 %290
%292 = load float, float* %291
%293 = fadd float %282, %292
%294 = call float @llvm.fmuladd.f32(float %272, float %293, float %269)
%295 = load float*, float** %24
%296 = getelementptr inbounds float, float* %295, i64 1
%297 = load float, float* %296
%298 = load float**, float*** %15
%299 = load i32, i32* %28
%300 = add nsw i32 %299, 2
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds float*, float** %298, i64 %301
%303 = load float*, float** %302
%304 = load i32, i32* %27
%305 = sext i32 %304 to i64
%306 = getelementptr inbounds float, float* %303, i64 %305
%307 = load float, float* %306
%308 = load float**, float*** %15
%309 = load i32, i32* %28
%310 = sub nsw i32 %309, 2
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds float*, float** %308, i64 %311
%313 = load float*, float** %312
%314 = load i32, i32* %27
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds float, float* %313, i64 %315
%317 = load float, float* %316
%318 = fadd float %307, %317
%319 = call float @llvm.fmuladd.f32(float %297, float %318, float %294)
%320 = fmul float %208, %319
%321 = fpext float %320 to double
%322 = fadd double %199, %321
%323 = fptrunc double %322 to float
%324 = load float**, float*** %17
%325 = load i32, i32* %28
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds float*, float** %324, i64 %326
%328 = load float*, float** %327
%329 = load i32, i32* %27
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds float, float* %328, i64 %330
store float %323, float* %331
%332 = load float**, float*** %14
%333 = load i32, i32* %28
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds float*, float** %332, i64 %334
%336 = load float*, float** %335
%337 = load i32, i32* %27
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds float, float* %336, i64 %338
%340 = load float, float* %339
%341 = fpext float %340 to double
%342 = load float**, float*** %16
%343 = load i32, i32* %28
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds float*, float** %342, i64 %344
%346 = load float*, float** %345
%347 = load i32, i32* %27
%348 = sext i32 %347 to i64
%349 = getelementptr inbounds float, float* %346, i64 %348
%350 = load float, float* %349
%351 = fpext float %350 to double
%352 = fneg double %351
%353 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %341, double %352)
%354 = load float**, float*** %18
%355 = load i32, i32* %28
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds float*, float** %354, i64 %356
%358 = load float*, float** %357
%359 = load i32, i32* %27
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds float, float* %358, i64 %360
%362 = load float, float* %361
%363 = load float, float* %31
%364 = fmul float %362, %363
%365 = fpext float %364 to double
%366 = fadd double %353, %365
%367 = fptrunc double %366 to float
%368 = load float**, float*** %16
%369 = load i32, i32* %28
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds float*, float** %368, i64 %370
%372 = load float*, float** %371
%373 = load i32, i32* %27
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds float, float* %372, i64 %374
store float %367, float* %375
br label %376
376: ; preds = %53
%377 = load i32, i32* %27
%378 = add nsw i32 %377, 1
store i32 %378, i32* %27
br label %49
379: ; preds = %49
br label %380
380: ; preds = %379
%381 = load i32, i32* %28
%382 = add nsw i32 %381, 1
store i32 %382, i32* %28
br label %41
383: ; preds = %41
%384 = load i32*, i32** %25
%385 = getelementptr inbounds i32, i32* %384, i64 1
%386 = load i32, i32* %385
%387 = icmp ne i32 %386, 0
br i1 %387, label %388, label %445
388: ; preds = %383
%389 = load i32, i32* %29
store i32 %389, i32* %27
br label %390
390: ; preds = %441, %388
%391 = load i32, i32* %27
%392 = load i32, i32* %30
%393 = icmp sle i32 %391, %392
br i1 %393, label %394, label %444
394: ; preds = %390
%395 = load float**, float*** %17
%396 = load i32*, i32** %20
%397 = getelementptr inbounds i32, i32* %396, i64 1
%398 = load i32, i32* %397
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds float*, float** %395, i64 %399
%401 = load float*, float** %400
%402 = load i32, i32* %27
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds float, float* %401, i64 %403
%405 = load float, float* %404
%406 = fneg float %405
%407 = load float**, float*** %17
%408 = load i32*, i32** %20
%409 = getelementptr inbounds i32, i32* %408, i64 1
%410 = load i32, i32* %409
%411 = sub nsw i32 %410, 2
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds float*, float** %407, i64 %412
%414 = load float*, float** %413
%415 = load i32, i32* %27
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds float, float* %414, i64 %416
store float %406, float* %417
%418 = load float**, float*** %16
%419 = load i32*, i32** %20
%420 = getelementptr inbounds i32, i32* %419, i64 1
%421 = load i32, i32* %420
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds float*, float** %418, i64 %422
%424 = load float*, float** %423
%425 = load i32, i32* %27
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds float, float* %424, i64 %426
%428 = load float, float* %427
%429 = fneg float %428
%430 = load float**, float*** %16
%431 = load i32*, i32** %20
%432 = getelementptr inbounds i32, i32* %431, i64 1
%433 = load i32, i32* %432
%434 = sub nsw i32 %433, 2
%435 = sext i32 %434 to i64
%436 = getelementptr inbounds float*, float** %430, i64 %435
%437 = load float*, float** %436
%438 = load i32, i32* %27
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds float, float* %437, i64 %439
store float %429, float* %440
br label %441
441: ; preds = %394
%442 = load i32, i32* %27
%443 = add nsw i32 %442, 1
store i32 %443, i32* %27
br label %390
444: ; preds = %390
br label %445
445: ; preds = %444, %383
%446 = load i32*, i32** %26
%447 = getelementptr inbounds i32, i32* %446, i64 1
%448 = load i32, i32* %447
%449 = icmp ne i32 %448, 0
br i1 %449, label %450, label %507
450: ; preds = %445
%451 = load i32, i32* %29
store i32 %451, i32* %27
br label %452
452: ; preds = %503, %450
%453 = load i32, i32* %27
%454 = load i32, i32* %30
%455 = icmp sle i32 %453, %454
br i1 %455, label %456, label %506
456: ; preds = %452
%457 = load float**, float*** %17
%458 = load i32*, i32** %21
%459 = getelementptr inbounds i32, i32* %458, i64 1
%460 = load i32, i32* %459
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds float*, float** %457, i64 %461
%463 = load float*, float** %462
%464 = load i32, i32* %27
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds float, float* %463, i64 %465
%467 = load float, float* %466
%468 = fneg float %467
%469 = load float**, float*** %17
%470 = load i32*, i32** %21
%471 = getelementptr inbounds i32, i32* %470, i64 1
%472 = load i32, i32* %471
%473 = add nsw i32 %472, 2
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds float*, float** %469, i64 %474
%476 = load float*, float** %475
%477 = load i32, i32* %27
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds float, float* %476, i64 %478
store float %468, float* %479
%480 = load float**, float*** %16
%481 = load i32*, i32** %21
%482 = getelementptr inbounds i32, i32* %481, i64 1
%483 = load i32, i32* %482
%484 = sext i32 %483 to i64
%485 = getelementptr inbounds float*, float** %480, i64 %484
%486 = load float*, float** %485
%487 = load i32, i32* %27
%488 = sext i32 %487 to i64
%489 = getelementptr inbounds float, float* %486, i64 %488
%490 = load float, float* %489
%491 = fneg float %490
%492 = load float**, float*** %16
%493 = load i32*, i32** %21
%494 = getelementptr inbounds i32, i32* %493, i64 1
%495 = load i32, i32* %494
%496 = add nsw i32 %495, 2
%497 = sext i32 %496 to i64
%498 = getelementptr inbounds float*, float** %492, i64 %497
%499 = load float*, float** %498
%500 = load i32, i32* %27
%501 = sext i32 %500 to i64
%502 = getelementptr inbounds float, float* %499, i64 %501
store float %491, float* %502
br label %503
503: ; preds = %456
%504 = load i32, i32* %27
%505 = add nsw i32 %504, 1
store i32 %505, i32* %27
br label %452
506: ; preds = %452
br label %507
507: ; preds = %506, %445
%508 = load i32*, i32** %25
%509 = getelementptr inbounds i32, i32* %508, i64 0
%510 = load i32, i32* %509
%511 = icmp ne i32 %510, 0
br i1 %511, label %512, label %573
512: ; preds = %507
%513 = load i32*, i32** %20
%514 = getelementptr inbounds i32, i32* %513, i64 1
%515 = load i32, i32* %514
store i32 %515, i32* %28
br label %516
516: ; preds = %569, %512
%517 = load i32, i32* %28
%518 = load i32*, i32** %21
%519 = getelementptr inbounds i32, i32* %518, i64 1
%520 = load i32, i32* %519
%521 = icmp sle i32 %517, %520
br i1 %521, label %522, label %572
522: ; preds = %516
%523 = load float**, float*** %17
%524 = load i32, i32* %28
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds float*, float** %523, i64 %525
%527 = load float*, float** %526
%528 = load i32*, i32** %20
%529 = getelementptr inbounds i32, i32* %528, i64 0
%530 = load i32, i32* %529
%531 = sext i32 %530 to i64
%532 = getelementptr inbounds float, float* %527, i64 %531
%533 = load float, float* %532
%534 = fneg float %533
%535 = load float**, float*** %17
%536 = load i32, i32* %28
%537 = sext i32 %536 to i64
%538 = getelementptr inbounds float*, float** %535, i64 %537
%539 = load float*, float** %538
%540 = load i32*, i32** %20
%541 = getelementptr inbounds i32, i32* %540, i64 0
%542 = load i32, i32* %541
%543 = sub nsw i32 %542, 2
%544 = sext i32 %543 to i64
%545 = getelementptr inbounds float, float* %539, i64 %544
store float %534, float* %545
%546 = load float**, float*** %16
%547 = load i32, i32* %28
%548 = sext i32 %547 to i64
%549 = getelementptr inbounds float*, float** %546, i64 %548
%550 = load float*, float** %549
%551 = load i32*, i32** %20
%552 = getelementptr inbounds i32, i32* %551, i64 0
%553 = load i32, i32* %552
%554 = sext i32 %553 to i64
%555 = getelementptr inbounds float, float* %550, i64 %554
%556 = load float, float* %555
%557 = fneg float %556
%558 = load float**, float*** %16
%559 = load i32, i32* %28
%560 = sext i32 %559 to i64
%561 = getelementptr inbounds float*, float** %558, i64 %560
%562 = load float*, float** %561
%563 = load i32*, i32** %20
%564 = getelementptr inbounds i32, i32* %563, i64 0
%565 = load i32, i32* %564
%566 = sub nsw i32 %565, 2
%567 = sext i32 %566 to i64
%568 = getelementptr inbounds float, float* %562, i64 %567
store float %557, float* %568
br label %569
569: ; preds = %522
%570 = load i32, i32* %28
%571 = add nsw i32 %570, 1
store i32 %571, i32* %28
br label %516
572: ; preds = %516
br label %573
573: ; preds = %572, %507
%574 = load i32*, i32** %26
%575 = getelementptr inbounds i32, i32* %574, i64 0
%576 = load i32, i32* %575
%577 = icmp ne i32 %576, 0
br i1 %577, label %578, label %639
578: ; preds = %573
%579 = load i32*, i32** %20
%580 = getelementptr inbounds i32, i32* %579, i64 1
%581 = load i32, i32* %580
store i32 %581, i32* %28
br label %582
582: ; preds = %635, %578
%583 = load i32, i32* %28
%584 = load i32*, i32** %21
%585 = getelementptr inbounds i32, i32* %584, i64 1
%586 = load i32, i32* %585
%587 = icmp sle i32 %583, %586
br i1 %587, label %588, label %638
588: ; preds = %582
%589 = load float**, float*** %17
%590 = load i32, i32* %28
%591 = sext i32 %590 to i64
%592 = getelementptr inbounds float*, float** %589, i64 %591
%593 = load float*, float** %592
%594 = load i32*, i32** %21
%595 = getelementptr inbounds i32, i32* %594, i64 0
%596 = load i32, i32* %595
%597 = sext i32 %596 to i64
%598 = getelementptr inbounds float, float* %593, i64 %597
%599 = load float, float* %598
%600 = fneg float %599
%601 = load float**, float*** %17
%602 = load i32, i32* %28
%603 = sext i32 %602 to i64
%604 = getelementptr inbounds float*, float** %601, i64 %603
%605 = load float*, float** %604
%606 = load i32*, i32** %21
%607 = getelementptr inbounds i32, i32* %606, i64 0
%608 = load i32, i32* %607
%609 = add nsw i32 %608, 2
%610 = sext i32 %609 to i64
%611 = getelementptr inbounds float, float* %605, i64 %610
store float %600, float* %611
%612 = load float**, float*** %16
%613 = load i32, i32* %28
%614 = sext i32 %613 to i64
%615 = getelementptr inbounds float*, float** %612, i64 %614
%616 = load float*, float** %615
%617 = load i32*, i32** %21
%618 = getelementptr inbounds i32, i32* %617, i64 0
%619 = load i32, i32* %618
%620 = sext i32 %619 to i64
%621 = getelementptr inbounds float, float* %616, i64 %620
%622 = load float, float* %621
%623 = fneg float %622
%624 = load float**, float*** %16
%625 = load i32, i32* %28
%626 = sext i32 %625 to i64
%627 = getelementptr inbounds float*, float** %624, i64 %626
%628 = load float*, float** %627
%629 = load i32*, i32** %21
%630 = getelementptr inbounds i32, i32* %629, i64 0
%631 = load i32, i32* %630
%632 = add nsw i32 %631, 2
%633 = sext i32 %632 to i64
%634 = getelementptr inbounds float, float* %628, i64 %633
store float %623, float* %634
br label %635
635: ; preds = %588
%636 = load i32, i32* %28
%637 = add nsw i32 %636, 1
store i32 %637, i32* %28
br label %582
638: ; preds = %582
br label %639
639: ; preds = %638, %573
ret void
}

LLVM IR (-O2):
define void @acd_2d_4_d(float** nocapture %0, float** nocapture %1, float** nocapture %2, float** nocapture %3, float** nocapture %4, float** nocapture %5, i32* nocapture %6, i32* nocapture %7, float %8, float* nocapture %9, float* nocapture %10, i32* nocapture %11, i32* nocapture %12) {
%14 = load i32, i32* %6
%15 = load i32, i32* %7
%16 = getelementptr inbounds i32, i32* %6, i64 1
%17 = load i32, i32* %16
%18 = getelementptr inbounds i32, i32* %7, i64 1
%19 = load i32, i32* %18
%20 = icmp slt i32 %19, %17
br i1 %20, label %165, label %21
21: ; preds = %13
%22 = icmp slt i32 %15, %14
%23 = getelementptr inbounds float, float* %9, i64 1
%24 = getelementptr inbounds float, float* %10, i64 1
%25 = sext i32 %14 to i64
%26 = add i32 %15, 1
%27 = sext i32 %17 to i64
%28 = add i32 %19, 1
br label %29
29: ; preds = %21, %161
%30 = phi i64 [ %27, %21 ], [ %162, %161 ]
br i1 %22, label %31, label %33
31: ; preds = %29
%32 = add nsw i64 %30, 1
br label %161
33: ; preds = %29
%34 = getelementptr inbounds float*, float** %0, i64 %30
%35 = load float*, float** %34
%36 = add nsw i64 %30, 1
%37 = getelementptr inbounds float*, float** %0, i64 %36
%38 = load float*, float** %37
%39 = add nsw i64 %30, -1
%40 = getelementptr inbounds float*, float** %0, i64 %39
%41 = load float*, float** %40
%42 = add nsw i64 %30, 2
%43 = getelementptr inbounds float*, float** %0, i64 %42
%44 = load float*, float** %43
%45 = add nsw i64 %30, -2
%46 = getelementptr inbounds float*, float** %0, i64 %45
%47 = load float*, float** %46
%48 = getelementptr inbounds float*, float** %1, i64 %30
%49 = load float*, float** %48
%50 = getelementptr inbounds float*, float** %3, i64 %30
%51 = load float*, float** %50
%52 = getelementptr inbounds float*, float** %5, i64 %30
%53 = load float*, float** %52
%54 = getelementptr inbounds float*, float** %4, i64 %30
%55 = load float*, float** %54
%56 = getelementptr inbounds float*, float** %1, i64 %36
%57 = load float*, float** %56
%58 = getelementptr inbounds float*, float** %1, i64 %39
%59 = load float*, float** %58
%60 = getelementptr inbounds float*, float** %1, i64 %42
%61 = load float*, float** %60
%62 = getelementptr inbounds float*, float** %1, i64 %45
%63 = load float*, float** %62
%64 = getelementptr inbounds float*, float** %2, i64 %30
%65 = load float*, float** %64
br label %66
66: ; preds = %33, %66
%67 = phi i64 [ %25, %33 ], [ %71, %66 ]
%68 = getelementptr inbounds float, float* %35, i64 %67
%69 = load float, float* %68
%70 = load float, float* %9
%71 = add nsw i64 %67, 1
%72 = getelementptr inbounds float, float* %35, i64 %71
%73 = load float, float* %72
%74 = add nsw i64 %67, -1
%75 = getelementptr inbounds float, float* %35, i64 %74
%76 = load float, float* %75
%77 = fadd float %73, %76
%78 = fmul float %70, %77
%79 = tail call float @llvm.fmuladd.f32(float %8, float %69, float %78)
%80 = load float, float* %23
%81 = getelementptr inbounds float, float* %38, i64 %67
%82 = load float, float* %81
%83 = getelementptr inbounds float, float* %41, i64 %67
%84 = load float, float* %83
%85 = fadd float %82, %84
%86 = tail call float @llvm.fmuladd.f32(float %80, float %85, float %79)
%87 = load float, float* %10
%88 = add nsw i64 %67, 2
%89 = getelementptr inbounds float, float* %35, i64 %88
%90 = load float, float* %89
%91 = add nsw i64 %67, -2
%92 = getelementptr inbounds float, float* %35, i64 %91
%93 = load float, float* %92
%94 = fadd float %90, %93
%95 = tail call float @llvm.fmuladd.f32(float %87, float %94, float %86)
%96 = load float, float* %24
%97 = getelementptr inbounds float, float* %44, i64 %67
%98 = load float, float* %97
%99 = getelementptr inbounds float, float* %47, i64 %67
%100 = load float, float* %99
%101 = fadd float %98, %100
%102 = tail call float @llvm.fmuladd.f32(float %96, float %101, float %95)
%103 = getelementptr inbounds float, float* %49, i64 %67
%104 = load float, float* %103
%105 = fpext float %104 to double
%106 = getelementptr inbounds float, float* %51, i64 %67
%107 = load float, float* %106
%108 = fpext float %107 to double
%109 = fneg double %108
%110 = tail call double @llvm.fmuladd.f64(double %105, double 2.000000e+00, double %109)
%111 = getelementptr inbounds float, float* %53, i64 %67
%112 = load float, float* %111
%113 = fmul float %102, %112
%114 = fpext float %113 to double
%115 = fadd double %110, %114
%116 = getelementptr inbounds float, float* %55, i64 %67
%117 = load float, float* %116
%118 = getelementptr inbounds float, float* %49, i64 %71
%119 = load float, float* %118
%120 = getelementptr inbounds float, float* %49, i64 %74
%121 = load float, float* %120
%122 = fadd float %119, %121
%123 = fmul float %70, %122
%124 = tail call float @llvm.fmuladd.f32(float %8, float %104, float %123)
%125 = getelementptr inbounds float, float* %57, i64 %67
%126 = load float, float* %125
%127 = getelementptr inbounds float, float* %59, i64 %67
%128 = load float, float* %127
%129 = fadd float %126, %128
%130 = tail call float @llvm.fmuladd.f32(float %80, float %129, float %124)
%131 = getelementptr inbounds float, float* %49, i64 %88
%132 = load float, float* %131
%133 = getelementptr inbounds float, float* %49, i64 %91
%134 = load float, float* %133
%135 = fadd float %132, %134
%136 = tail call float @llvm.fmuladd.f32(float %87, float %135, float %130)
%137 = getelementptr inbounds float, float* %61, i64 %67
%138 = load float, float* %137
%139 = getelementptr inbounds float, float* %63, i64 %67
%140 = load float, float* %139
%141 = fadd float %138, %140
%142 = tail call float @llvm.fmuladd.f32(float %96, float %141, float %136)
%143 = fmul float %117, %142
%144 = fpext float %143 to double
%145 = fadd double %115, %144
%146 = fptrunc double %145 to float
store float %146, float* %106
%147 = load float, float* %68
%148 = fpext float %147 to double
%149 = getelementptr inbounds float, float* %65, i64 %67
%150 = load float, float* %149
%151 = fpext float %150 to double
%152 = fneg double %151
%153 = tail call double @llvm.fmuladd.f64(double %148, double 2.000000e+00, double %152)
%154 = load float, float* %116
%155 = fmul float %102, %154
%156 = fpext float %155 to double
%157 = fadd double %153, %156
%158 = fptrunc double %157 to float
store float %158, float* %149
%159 = trunc i64 %71 to i32
%160 = icmp eq i32 %26, %159
br i1 %160, label %161, label %66
161: ; preds = %66, %31
%162 = phi i64 [ %32, %31 ], [ %36, %66 ]
%163 = trunc i64 %162 to i32
%164 = icmp eq i32 %28, %163
br i1 %164, label %165, label %29
165: ; preds = %161, %13
%166 = getelementptr inbounds i32, i32* %11, i64 1
%167 = load i32, i32* %166
%168 = icmp eq i32 %167, 0
%169 = icmp slt i32 %15, %14
%170 = select i1 %168, i1 true, i1 %169
br i1 %170, label %297, label %171
171: ; preds = %165
%172 = sext i32 %17 to i64
%173 = getelementptr inbounds float*, float** %3, i64 %172
%174 = load float*, float** %173
%175 = add nsw i32 %17, -2
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds float*, float** %3, i64 %176
%178 = load float*, float** %177
%179 = getelementptr inbounds float*, float** %2, i64 %172
%180 = load float*, float** %179
%181 = getelementptr inbounds float*, float** %2, i64 %176
%182 = load float*, float** %181
%183 = sext i32 %14 to i64
%184 = add i32 %15, 1
%185 = sub i32 %15, %14
%186 = zext i32 %185 to i64
%187 = add nuw nsw i64 %186, 1
%188 = icmp ult i32 %185, 7
br i1 %188, label %255, label %189
189: ; preds = %171
%190 = getelementptr float, float* %178, i64 %183
%191 = sub i32 %15, %14
%192 = zext i32 %191 to i64
%193 = add nsw i64 %183, %192
%194 = add nsw i64 %193, 1
%195 = getelementptr float, float* %178, i64 %194
%196 = getelementptr float, float* %182, i64 %183
%197 = getelementptr float, float* %182, i64 %194
%198 = getelementptr float, float* %174, i64 %183
%199 = getelementptr float, float* %174, i64 %194
%200 = getelementptr float, float* %180, i64 %183
%201 = getelementptr float, float* %180, i64 %194
%202 = icmp ult float* %190, %197
%203 = icmp ult float* %196, %195
%204 = and i1 %202, %203
%205 = icmp ult float* %190, %199
%206 = icmp ult float* %198, %195
%207 = and i1 %205, %206
%208 = or i1 %204, %207
%209 = icmp ult float* %190, %201
%210 = icmp ult float* %200, %195
%211 = and i1 %209, %210
%212 = or i1 %208, %211
%213 = icmp ult float* %196, %199
%214 = icmp ult float* %198, %197
%215 = and i1 %213, %214
%216 = or i1 %212, %215
%217 = icmp ult float* %196, %201
%218 = icmp ult float* %200, %197
%219 = and i1 %217, %218
%220 = or i1 %216, %219
br i1 %220, label %255, label %221
221: ; preds = %189
%222 = and i64 %187, 8589934584
%223 = add nsw i64 %222, %183
br label %224
224: ; preds = %224, %221
%225 = phi i64 [ 0, %221 ], [ %251, %224 ]
%226 = add i64 %225, %183
%227 = getelementptr inbounds float, float* %174, i64 %226
%228 = bitcast float* %227 to <4 x float>*
%229 = load <4 x float>, <4 x float>* %228
%230 = getelementptr inbounds float, float* %227, i64 4
%231 = bitcast float* %230 to <4 x float>*
%232 = load <4 x float>, <4 x float>* %231
%233 = fneg <4 x float> %229
%234 = fneg <4 x float> %232
%235 = getelementptr inbounds float, float* %178, i64 %226
%236 = bitcast float* %235 to <4 x float>*
store <4 x float> %233, <4 x float>* %236
%237 = getelementptr inbounds float, float* %235, i64 4
%238 = bitcast float* %237 to <4 x float>*
store <4 x float> %234, <4 x float>* %238
%239 = getelementptr inbounds float, float* %180, i64 %226
%240 = bitcast float* %239 to <4 x float>*
%241 = load <4 x float>, <4 x float>* %240
%242 = getelementptr inbounds float, float* %239, i64 4
%243 = bitcast float* %242 to <4 x float>*
%244 = load <4 x float>, <4 x float>* %243
%245 = fneg <4 x float> %241
%246 = fneg <4 x float> %244
%247 = getelementptr inbounds float, float* %182, i64 %226
%248 = bitcast float* %247 to <4 x float>*
store <4 x float> %245, <4 x float>* %248
%249 = getelementptr inbounds float, float* %247, i64 4
%250 = bitcast float* %249 to <4 x float>*
store <4 x float> %246, <4 x float>* %250
%251 = add nuw i64 %225, 8
%252 = icmp eq i64 %251, %222
br i1 %252, label %253, label %224
253: ; preds = %224
%254 = icmp eq i64 %187, %222
br i1 %254, label %297, label %255
255: ; preds = %189, %171, %253
%256 = phi i64 [ %183, %189 ], [ %183, %171 ], [ %223, %253 ]
%257 = add i32 %15, 1
%258 = trunc i64 %256 to i32
%259 = sub i32 %257, %258
%260 = and i32 %259, 1
%261 = icmp eq i32 %260, 0
br i1 %261, label %272, label %262
262: ; preds = %255
%263 = getelementptr inbounds float, float* %174, i64 %256
%264 = load float, float* %263
%265 = fneg float %264
%266 = getelementptr inbounds float, float* %178, i64 %256
store float %265, float* %266
%267 = getelementptr inbounds float, float* %180, i64 %256
%268 = load float, float* %267
%269 = fneg float %268
%270 = getelementptr inbounds float, float* %182, i64 %256
store float %269, float* %270
%271 = add nsw i64 %256, 1
br label %272
272: ; preds = %262, %255
%273 = phi i64 [ %256, %255 ], [ %271, %262 ]
%274 = icmp eq i32 %15, %258
br i1 %274, label %297, label %275
275: ; preds = %272, %275
%276 = phi i64 [ %294, %275 ], [ %273, %272 ]
%277 = getelementptr inbounds float, float* %174, i64 %276
%278 = load float, float* %277
%279 = fneg float %278
%280 = getelementptr inbounds float, float* %178, i64 %276
store float %279, float* %280
%281 = getelementptr inbounds float, float* %180, i64 %276
%282 = load float, float* %281
%283 = fneg float %282
%284 = getelementptr inbounds float, float* %182, i64 %276
store float %283, float* %284
%285 = add nsw i64 %276, 1
%286 = getelementptr inbounds float, float* %174, i64 %285
%287 = load float, float* %286
%288 = fneg float %287
%289 = getelementptr inbounds float, float* %178, i64 %285
store float %288, float* %289
%290 = getelementptr inbounds float, float* %180, i64 %285
%291 = load float, float* %290
%292 = fneg float %291
%293 = getelementptr inbounds float, float* %182, i64 %285
store float %292, float* %293
%294 = add nsw i64 %276, 2
%295 = trunc i64 %294 to i32
%296 = icmp eq i32 %184, %295
br i1 %296, label %297, label %275
297: ; preds = %272, %275, %253, %165
%298 = getelementptr inbounds i32, i32* %12, i64 1
%299 = load i32, i32* %298
%300 = icmp eq i32 %299, 0
%301 = select i1 %300, i1 true, i1 %169
br i1 %301, label %428, label %302
302: ; preds = %297
%303 = sext i32 %19 to i64
%304 = getelementptr inbounds float*, float** %3, i64 %303
%305 = load float*, float** %304
%306 = add nsw i32 %19, 2
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds float*, float** %3, i64 %307
%309 = load float*, float** %308
%310 = getelementptr inbounds float*, float** %2, i64 %303
%311 = load float*, float** %310
%312 = getelementptr inbounds float*, float** %2, i64 %307
%313 = load float*, float** %312
%314 = sext i32 %14 to i64
%315 = add i32 %15, 1
%316 = sub i32 %15, %14
%317 = zext i32 %316 to i64
%318 = add nuw nsw i64 %317, 1
%319 = icmp ult i32 %316, 7
br i1 %319, label %386, label %320
320: ; preds = %302
%321 = getelementptr float, float* %309, i64 %314
%322 = sub i32 %15, %14
%323 = zext i32 %322 to i64
%324 = add nsw i64 %314, %323
%325 = add nsw i64 %324, 1
%326 = getelementptr float, float* %309, i64 %325
%327 = getelementptr float, float* %313, i64 %314
%328 = getelementptr float, float* %313, i64 %325
%329 = getelementptr float, float* %305, i64 %314
%330 = getelementptr float, float* %305, i64 %325
%331 = getelementptr float, float* %311, i64 %314
%332 = getelementptr float, float* %311, i64 %325
%333 = icmp ult float* %321, %328
%334 = icmp ult float* %327, %326
%335 = and i1 %333, %334
%336 = icmp ult float* %321, %330
%337 = icmp ult float* %329, %326
%338 = and i1 %336, %337
%339 = or i1 %335, %338
%340 = icmp ult float* %321, %332
%341 = icmp ult float* %331, %326
%342 = and i1 %340, %341
%343 = or i1 %339, %342
%344 = icmp ult float* %327, %330
%345 = icmp ult float* %329, %328
%346 = and i1 %344, %345
%347 = or i1 %343, %346
%348 = icmp ult float* %327, %332
%349 = icmp ult float* %331, %328
%350 = and i1 %348, %349
%351 = or i1 %347, %350
br i1 %351, label %386, label %352
352: ; preds = %320
%353 = and i64 %318, 8589934584
%354 = add nsw i64 %353, %314
br label %355
355: ; preds = %355, %352
%356 = phi i64 [ 0, %352 ], [ %382, %355 ]
%357 = add i64 %356, %314
%358 = getelementptr inbounds float, float* %305, i64 %357
%359 = bitcast float* %358 to <4 x float>*
%360 = load <4 x float>, <4 x float>* %359
%361 = getelementptr inbounds float, float* %358, i64 4
%362 = bitcast float* %361 to <4 x float>*
%363 = load <4 x float>, <4 x float>* %362
%364 = fneg <4 x float> %360
%365 = fneg <4 x float> %363
%366 = getelementptr inbounds float, float* %309, i64 %357
%367 = bitcast float* %366 to <4 x float>*
store <4 x float> %364, <4 x float>* %367
%368 = getelementptr inbounds float, float* %366, i64 4
%369 = bitcast float* %368 to <4 x float>*
store <4 x float> %365, <4 x float>* %369
%370 = getelementptr inbounds float, float* %311, i64 %357
%371 = bitcast float* %370 to <4 x float>*
%372 = load <4 x float>, <4 x float>* %371
%373 = getelementptr inbounds float, float* %370, i64 4
%374 = bitcast float* %373 to <4 x float>*
%375 = load <4 x float>, <4 x float>* %374
%376 = fneg <4 x float> %372
%377 = fneg <4 x float> %375
%378 = getelementptr inbounds float, float* %313, i64 %357
%379 = bitcast float* %378 to <4 x float>*
store <4 x float> %376, <4 x float>* %379
%380 = getelementptr inbounds float, float* %378, i64 4
%381 = bitcast float* %380 to <4 x float>*
store <4 x float> %377, <4 x float>* %381
%382 = add nuw i64 %356, 8
%383 = icmp eq i64 %382, %353
br i1 %383, label %384, label %355
384: ; preds = %355
%385 = icmp eq i64 %318, %353
br i1 %385, label %428, label %386
386: ; preds = %320, %302, %384
%387 = phi i64 [ %314, %320 ], [ %314, %302 ], [ %354, %384 ]
%388 = add i32 %15, 1
%389 = trunc i64 %387 to i32
%390 = sub i32 %388, %389
%391 = and i32 %390, 1
%392 = icmp eq i32 %391, 0
br i1 %392, label %403, label %393
393: ; preds = %386
%394 = getelementptr inbounds float, float* %305, i64 %387
%395 = load float, float* %394
%396 = fneg float %395
%397 = getelementptr inbounds float, float* %309, i64 %387
store float %396, float* %397
%398 = getelementptr inbounds float, float* %311, i64 %387
%399 = load float, float* %398
%400 = fneg float %399
%401 = getelementptr inbounds float, float* %313, i64 %387
store float %400, float* %401
%402 = add nsw i64 %387, 1
br label %403
403: ; preds = %393, %386
%404 = phi i64 [ %387, %386 ], [ %402, %393 ]
%405 = icmp eq i32 %15, %389
br i1 %405, label %428, label %406
406: ; preds = %403, %406
%407 = phi i64 [ %425, %406 ], [ %404, %403 ]
%408 = getelementptr inbounds float, float* %305, i64 %407
%409 = load float, float* %408
%410 = fneg float %409
%411 = getelementptr inbounds float, float* %309, i64 %407
store float %410, float* %411
%412 = getelementptr inbounds float, float* %311, i64 %407
%413 = load float, float* %412
%414 = fneg float %413
%415 = getelementptr inbounds float, float* %313, i64 %407
store float %414, float* %415
%416 = add nsw i64 %407, 1
%417 = getelementptr inbounds float, float* %305, i64 %416
%418 = load float, float* %417
%419 = fneg float %418
%420 = getelementptr inbounds float, float* %309, i64 %416
store float %419, float* %420
%421 = getelementptr inbounds float, float* %311, i64 %416
%422 = load float, float* %421
%423 = fneg float %422
%424 = getelementptr inbounds float, float* %313, i64 %416
store float %423, float* %424
%425 = add nsw i64 %407, 2
%426 = trunc i64 %425 to i32
%427 = icmp eq i32 %315, %426
br i1 %427, label %428, label %406
428: ; preds = %403, %406, %384, %297
%429 = load i32, i32* %11
%430 = icmp eq i32 %429, 0
%431 = select i1 %430, i1 true, i1 %20
br i1 %431, label %488, label %432
432: ; preds = %428
%433 = sext i32 %14 to i64
%434 = add nsw i32 %14, -2
%435 = sext i32 %434 to i64
%436 = sext i32 %17 to i64
%437 = add i32 %19, 1
%438 = sub i32 %437, %17
%439 = and i32 %438, 1
%440 = icmp eq i32 %439, 0
br i1 %440, label %455, label %441
441: ; preds = %432
%442 = getelementptr inbounds float*, float** %3, i64 %436
%443 = load float*, float** %442
%444 = getelementptr inbounds float, float* %443, i64 %433
%445 = load float, float* %444
%446 = fneg float %445
%447 = getelementptr inbounds float, float* %443, i64 %435
store float %446, float* %447
%448 = getelementptr inbounds float*, float** %2, i64 %436
%449 = load float*, float** %448
%450 = getelementptr inbounds float, float* %449, i64 %433
%451 = load float, float* %450
%452 = fneg float %451
%453 = getelementptr inbounds float, float* %449, i64 %435
store float %452, float* %453
%454 = add nsw i64 %436, 1
br label %455
455: ; preds = %441, %432
%456 = phi i64 [ %436, %432 ], [ %454, %441 ]
%457 = icmp eq i32 %19, %17
br i1 %457, label %488, label %458
458: ; preds = %455, %458
%459 = phi i64 [ %485, %458 ], [ %456, %455 ]
%460 = getelementptr inbounds float*, float** %3, i64 %459
%461 = load float*, float** %460
%462 = getelementptr inbounds float, float* %461, i64 %433
%463 = load float, float* %462
%464 = fneg float %463
%465 = getelementptr inbounds float, float* %461, i64 %435
store float %464, float* %465
%466 = getelementptr inbounds float*, float** %2, i64 %459
%467 = load float*, float** %466
%468 = getelementptr inbounds float, float* %467, i64 %433
%469 = load float, float* %468
%470 = fneg float %469
%471 = getelementptr inbounds float, float* %467, i64 %435
store float %470, float* %471
%472 = add nsw i64 %459, 1
%473 = getelementptr inbounds float*, float** %3, i64 %472
%474 = load float*, float** %473
%475 = getelementptr inbounds float, float* %474, i64 %433
%476 = load float, float* %475
%477 = fneg float %476
%478 = getelementptr inbounds float, float* %474, i64 %435
store float %477, float* %478
%479 = getelementptr inbounds float*, float** %2, i64 %472
%480 = load float*, float** %479
%481 = getelementptr inbounds float, float* %480, i64 %433
%482 = load float, float* %481
%483 = fneg float %482
%484 = getelementptr inbounds float, float* %480, i64 %435
store float %483, float* %484
%485 = add nsw i64 %459, 2
%486 = trunc i64 %485 to i32
%487 = icmp eq i32 %437, %486
br i1 %487, label %488, label %458
488: ; preds = %455, %458, %428
%489 = load i32, i32* %12
%490 = icmp eq i32 %489, 0
%491 = select i1 %490, i1 true, i1 %20
br i1 %491, label %548, label %492
492: ; preds = %488
%493 = sext i32 %15 to i64
%494 = add nsw i32 %15, 2
%495 = sext i32 %494 to i64
%496 = sext i32 %17 to i64
%497 = add i32 %19, 1
%498 = sub i32 %497, %17
%499 = and i32 %498, 1
%500 = icmp eq i32 %499, 0
br i1 %500, label %515, label %501
501: ; preds = %492
%502 = getelementptr inbounds float*, float** %3, i64 %496
%503 = load float*, float** %502
%504 = getelementptr inbounds float, float* %503, i64 %493
%505 = load float, float* %504
%506 = fneg float %505
%507 = getelementptr inbounds float, float* %503, i64 %495
store float %506, float* %507
%508 = getelementptr inbounds float*, float** %2, i64 %496
%509 = load float*, float** %508
%510 = getelementptr inbounds float, float* %509, i64 %493
%511 = load float, float* %510
%512 = fneg float %511
%513 = getelementptr inbounds float, float* %509, i64 %495
store float %512, float* %513
%514 = add nsw i64 %496, 1
br label %515
515: ; preds = %501, %492
%516 = phi i64 [ %496, %492 ], [ %514, %501 ]
%517 = icmp eq i32 %19, %17
br i1 %517, label %548, label %518
518: ; preds = %515, %518
%519 = phi i64 [ %545, %518 ], [ %516, %515 ]
%520 = getelementptr inbounds float*, float** %3, i64 %519
%521 = load float*, float** %520
%522 = getelementptr inbounds float, float* %521, i64 %493
%523 = load float, float* %522
%524 = fneg float %523
%525 = getelementptr inbounds float, float* %521, i64 %495
store float %524, float* %525
%526 = getelementptr inbounds float*, float** %2, i64 %519
%527 = load float*, float** %526
%528 = getelementptr inbounds float, float* %527, i64 %493
%529 = load float, float* %528
%530 = fneg float %529
%531 = getelementptr inbounds float, float* %527, i64 %495
store float %530, float* %531
%532 = add nsw i64 %519, 1
%533 = getelementptr inbounds float*, float** %3, i64 %532
%534 = load float*, float** %533
%535 = getelementptr inbounds float, float* %534, i64 %493
%536 = load float, float* %535
%537 = fneg float %536
%538 = getelementptr inbounds float, float* %534, i64 %495
store float %537, float* %538
%539 = getelementptr inbounds float*, float** %2, i64 %532
%540 = load float*, float** %539
%541 = getelementptr inbounds float, float* %540, i64 %493
%542 = load float, float* %541
%543 = fneg float %542
%544 = getelementptr inbounds float, float* %540, i64 %495
store float %543, float* %544
%545 = add nsw i64 %519, 2
%546 = trunc i64 %545 to i32
%547 = icmp eq i32 %497, %546
br i1 %547, label %548, label %518
548: ; preds = %515, %518, %488
ret void
}