#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double exp(double);
double fabs(double);
void updateMatrix(float **image, float **imageOld, int m, int n, int CC,
                  double k, double lambda) {
  double diffN;
  double diffS;
  double diffE;
  double diffW;
  double cN;
  double cS;
  double cE;
  double cW;
  double gradN, gradS, gradE, gradW;
  double wCen = 0.5;
  double wSide = 0.25;
  double ksq = k * k;
  int i, j, ip1, im1, jp1, jm1;
  for (i = 1; i < m + 1; i++) {
    ip1 = i == m ? m : i + 1;
    im1 = i == 1 ? 1 : i - 1;
    for (j = 1; j < n + 1; j++) {
      jp1 = j == n ? n : j + 1;
      jm1 = j == 1 ? 1 : j - 1;
      gradN = diffN = imageOld[im1][j] - imageOld[i][j];
      gradS = diffS = imageOld[ip1][j] - imageOld[i][j];
      gradE = diffE = imageOld[i][jp1] - imageOld[i][j];
      gradW = diffW = imageOld[i][jm1] - imageOld[i][j];
      if (CC == 1) {
        cN = exp(-gradN * gradN / ksq);
        cS = exp(-gradS * gradS / ksq);
        cE = exp(-gradE * gradE / ksq);
        cW = exp(-gradW * gradW / ksq);
      } else if (CC == 2) {
        cN = 1 / (1 + gradN * gradN / ksq);
        cS = 1 / (1 + gradS * gradS / ksq);
        cE = 1 / (1 + gradE * gradE / ksq);
        cW = 1 / (1 + gradW * gradW / ksq);
      } else {
        if (fabs(diffN) > k)
          cN = 0;
        else
          cN = 0.5 * (1 - gradN * gradN / ksq) * (1 - gradN * gradN / ksq);
        if (fabs(diffS) > k)
          cS = 0;
        else
          cS = 0.5 * (1 - gradS * gradS / ksq) * (1 - gradS * gradS / ksq);
        if (fabs(diffE) > k)
          cE = 0;
        else
          cE = 0.5 * (1 - gradE * gradE / ksq) * (1 - gradE * gradE / ksq);
        if (fabs(diffW) > k)
          cW = 0;
        else
          cW = 0.5 * (1 - gradW * gradW / ksq) * (1 - gradW * gradW / ksq);
      }
      image[i][j] = imageOld[i][j] + lambda * (cN * diffN + cS * diffS +
                                               cE * diffE + cW * diffW);
    }
  }
}


x86 assembly (clang, -O0):
<updateMatrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
movsd  %xmm0,-0x28(%rbp)
movsd  %xmm1,-0x30(%rbp)
movsd  0xec9(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0xeb1(%rip),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x1,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1817 <updateMatrix+0x707>
mov    -0xac(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    11a4 <updateMatrix+0x94>
mov    -0x14(%rbp),%eax
mov    %eax,-0xc4(%rbp)
jmp    11b3 <updateMatrix+0xa3>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    %eax,-0xb4(%rbp)
cmpl   $0x1,-0xac(%rbp)
jne    11dc <updateMatrix+0xcc>
mov    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    11eb <updateMatrix+0xdb>
mov    -0xac(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
mov    %eax,-0xb8(%rbp)
movl   $0x1,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    17fe <updateMatrix+0x6ee>
mov    -0xb0(%rbp),%eax
cmp    -0x18(%rbp),%eax
jne    1232 <updateMatrix+0x122>
mov    -0x18(%rbp),%eax
mov    %eax,-0xcc(%rbp)
jmp    1241 <updateMatrix+0x131>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
mov    %eax,-0xbc(%rbp)
cmpl   $0x1,-0xb0(%rbp)
jne    126a <updateMatrix+0x15a>
mov    $0x1,%eax
mov    %eax,-0xd0(%rbp)
jmp    1279 <updateMatrix+0x169>
mov    -0xb0(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
mov    %eax,-0xc0(%rbp)
mov    -0x10(%rbp),%rax
movslq -0xb8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb0(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb0(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xbc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb0(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb0(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  %xmm0,-0x90(%rbp)
ff
cmpl   $0x1,-0x1c(%rbp)
jne    1482 <updateMatrix+0x372>
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x78(%rbp),%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
call   1030 <exp@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x80(%rbp),%xmm0
divsd  -0xa8(%rbp),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
divsd  -0xa8(%rbp),%xmm0
ff
call   1030 <exp@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
divsd  -0xa8(%rbp),%xmm0
ff
call   1030 <exp@plt>
movsd  %xmm0,-0x70(%rbp)
jmp    175f <updateMatrix+0x64f>
cmpl   $0x2,-0x1c(%rbp)
jne    1559 <updateMatrix+0x449>
movsd  -0x78(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
movsd  0xb6a(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0xb5e(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x80(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
movsd  0xb3b(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0xb2f(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
mulsd  -0x88(%rbp),%xmm0
ff
divsd  -0xa8(%rbp),%xmm0
ff
movsd  0xb06(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0xafa(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
divsd  -0xa8(%rbp),%xmm0
ff
movsd  0xad1(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0xac5(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    175a <updateMatrix+0x64a>
movsd  -0x38(%rbp),%xmm0
movaps 0xabb(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x28(%rbp),%xmm0
jbe    1581 <updateMatrix+0x471>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    15d2 <updateMatrix+0x4c2>
movsd  -0x78(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
movsd  0xa75(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  0xa61(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  -0x78(%rbp),%xmm2
mulsd  -0x78(%rbp),%xmm2
divsd  -0xa8(%rbp),%xmm2
ff
movsd  0xa4b(%rip),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x40(%rbp),%xmm0
movaps 0xa42(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x28(%rbp),%xmm0
jbe    15fa <updateMatrix+0x4ea>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    164b <updateMatrix+0x53b>
movsd  -0x80(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
movsd  0x9fc(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  0x9e8(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  -0x80(%rbp),%xmm2
mulsd  -0x80(%rbp),%xmm2
divsd  -0xa8(%rbp),%xmm2
ff
movsd  0x9d2(%rip),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x48(%rbp),%xmm0
movaps 0x9c9(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x28(%rbp),%xmm0
jbe    1673 <updateMatrix+0x563>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    16d0 <updateMatrix+0x5c0>
movsd  -0x88(%rbp),%xmm0
ff
mulsd  -0x88(%rbp),%xmm0
ff
divsd  -0xa8(%rbp),%xmm0
ff
movsd  0x97d(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  0x969(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  -0x88(%rbp),%xmm2
ff
mulsd  -0x88(%rbp),%xmm2
ff
divsd  -0xa8(%rbp),%xmm2
ff
movsd  0x94d(%rip),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x50(%rbp),%xmm0
movaps 0x944(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x28(%rbp),%xmm0
jbe    16f8 <updateMatrix+0x5e8>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    1755 <updateMatrix+0x645>
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
divsd  -0xa8(%rbp),%xmm0
ff
movsd  0x8f8(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  0x8e4(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  -0x90(%rbp),%xmm2
ff
mulsd  -0x90(%rbp),%xmm2
ff
divsd  -0xa8(%rbp),%xmm2
ff
movsd  0x8c8(%rip),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    175a <updateMatrix+0x64a>
jmp    175f <updateMatrix+0x64f>
mov    -0x10(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  -0x30(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm4
movsd  -0x60(%rbp),%xmm3
mulsd  -0x40(%rbp),%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movsd  -0x68(%rbp),%xmm3
movsd  -0x48(%rbp),%xmm4
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
movsd  -0x70(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb0(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1201 <updateMatrix+0xf1>
jmp    1803 <updateMatrix+0x6f3>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1173 <updateMatrix+0x63>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<updateMatrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %rcx,0x20(%rsp)
mov    %rdx,0x18(%rsp)
test   %edx,%edx
jle    15b1 <updateMatrix+0x4a1>
movapd %xmm0,%xmm8
movapd %xmm0,%xmm15
mulsd  %xmm8,%xmm15
mov    0x20(%rsp),%rax
mov    %eax,%ebx
lea    0x1(%rax),%r9d
mov    0x18(%rsp),%rax
mov    %eax,%ecx
mov    %rcx,0x68(%rsp)
add    $0x1,%eax
mov    %rax,0x70(%rsp)
mov    $0x1,%eax
movsd  0xe92(%rip),%xmm7
movabs $0x100000000,%r10
movaps 0xea0(%rip),%xmm10
movsd  0xe7f(%rip),%xmm9
movsd  %xmm1,0x90(%rsp)
movsd  %xmm0,0x88(%rsp)
movsd  %xmm15,0x8(%rsp)
mov    %rdi,0x80(%rsp)
mov    %r8d,0x14(%rsp)
mov    %r9,0x78(%rsp)
jmp    11d0 <updateMatrix+0xc0>
cs nopw 0x0(%rax,%rax,1)
mov    0x28(%rsp),%rax
cmp    0x70(%rsp),%rax
je     15b1 <updateMatrix+0x4a1>
mov    %rax,%r11
add    $0x1,%rax
mov    %rax,0x28(%rsp)
cmpl   $0x0,0x20(%rsp)
jle    11c0 <updateMatrix+0xb0>
cmp    0x68(%rsp),%r11
mov    0x28(%rsp),%rax
cmove  0x18(%rsp),%eax
lea    -0x1(%r11),%ecx
cmp    $0x1,%r11
movslq %ecx,%r14
cmove  %r11,%r14
movslq %eax,%r13
mov    (%rsi,%r11,8),%rax
mov    $0x1,%r15d
xor    %r12d,%r12d
mov    %r14,0xa0(%rsp)
mov    %r13,0x98(%rsp)
jmp    12e4 <updateMatrix+0x1d4>
cs nopw 0x0(%rax,%rax,1)
mulsd  %xmm14,%xmm0
divsd  %xmm15,%xmm0
addsd  %xmm7,%xmm0
movapd %xmm7,%xmm6
divsd  %xmm0,%xmm6
movapd %xmm12,%xmm0
mulsd  %xmm12,%xmm0
divsd  %xmm15,%xmm0
addsd  %xmm7,%xmm0
movapd %xmm7,%xmm3
divsd  %xmm0,%xmm3
movapd %xmm11,%xmm0
mulsd  %xmm11,%xmm0
divsd  %xmm15,%xmm0
addsd  %xmm7,%xmm0
movapd %xmm7,%xmm5
divsd  %xmm0,%xmm5
movapd %xmm13,%xmm2
mulsd  %xmm13,%xmm2
divsd  %xmm15,%xmm2
addsd  %xmm7,%xmm2
movapd %xmm7,%xmm0
divsd  %xmm2,%xmm0
xorps  %xmm2,%xmm2
cvtss2sd %xmm4,%xmm2
mulsd  %xmm12,%xmm3
mulsd  %xmm14,%xmm6
addsd  %xmm3,%xmm6
mulsd  %xmm11,%xmm5
addsd  %xmm6,%xmm5
mulsd  %xmm13,%xmm0
addsd  %xmm5,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    (%rdi,%r11,8),%rcx
movss  %xmm0,(%rcx,%r15,4)
add    %r10,%r12
add    $0x1,%r15
cmp    %r9,%r15
je     11c0 <updateMatrix+0xb0>
lea    0x1(%r15),%ecx
cmp    %r15,%rbx
cmove  %ebx,%ecx
mov    %r12,%rdx
sar    $0x20,%rdx
cmp    $0x1,%r15
mov    (%rsi,%r14,8),%rbp
movss  0x0(%rbp,%r15,4),%xmm0
movss  (%rax,%r15,4),%xmm4
subss  %xmm4,%xmm0
xorps  %xmm14,%xmm14
cvtss2sd %xmm0,%xmm14
mov    (%rsi,%r13,8),%rbp
movss  0x0(%rbp,%r15,4),%xmm0
subss  %xmm4,%xmm0
xorps  %xmm12,%xmm12
cvtss2sd %xmm0,%xmm12
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm4,%xmm0
xorps  %xmm11,%xmm11
cvtss2sd %xmm0,%xmm11
cmove  %r15,%rdx
movss  (%rax,%rdx,4),%xmm0
subss  %xmm4,%xmm0
xorps  %xmm13,%xmm13
cvtss2sd %xmm0,%xmm13
movaps %xmm14,%xmm0
cmp    $0x2,%r8d
je     1230 <updateMatrix+0x120>
cmp    $0x1,%r8d
jne    14d0 <updateMatrix+0x3c0>
movaps 0xc97(%rip),%xmm2
xorps  %xmm2,%xmm0
mulsd  %xmm14,%xmm0
divsd  %xmm15,%xmm0
mov    %rsi,%r13
mov    %r10,%r14
mov    %r11,%rbp
movaps %xmm14,0xc0(%rsp)
movaps %xmm11,0x50(%rsp)
movaps %xmm12,0x40(%rsp)
movaps %xmm13,0x30(%rsp)
call   1030 <exp@plt>
movsd  %xmm0,0xb8(%rsp)
movapd 0x40(%rsp),%xmm0
xorpd  0xc4a(%rip),%xmm0
mulsd  0x40(%rsp),%xmm0
divsd  0x8(%rsp),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0xb0(%rsp)
movapd 0x50(%rsp),%xmm0
xorpd  0xc22(%rip),%xmm0
mulsd  0x50(%rsp),%xmm0
divsd  0x8(%rsp),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0xa8(%rsp)
movapd 0x30(%rsp),%xmm0
xorpd  0xbfa(%rip),%xmm0
mulsd  0x30(%rsp),%xmm0
divsd  0x8(%rsp),%xmm0
call   1030 <exp@plt>
movsd  0xb0(%rsp),%xmm3
movsd  0xb8(%rsp),%xmm6
movaps 0x30(%rsp),%xmm13
movaps 0x40(%rsp),%xmm12
movaps 0x50(%rsp),%xmm11
movaps 0xc0(%rsp),%xmm14
mov    %rbp,%r11
movsd  0xba8(%rip),%xmm9
movaps 0xbb8(%rip),%xmm10
movsd  0xa8(%rsp),%xmm5
mov    %r14,%r10
mov    0xa0(%rsp),%r14
movsd  0xb7c(%rip),%xmm7
mov    %r13,%rsi
mov    0x98(%rsp),%r13
mov    0x78(%rsp),%r9
movsd  0x8(%rsp),%xmm15
mov    0x14(%rsp),%r8d
mov    0x80(%rsp),%rdi
movsd  0x88(%rsp),%xmm8
movsd  0x90(%rsp),%xmm1
mov    (%rsi,%rbp,8),%rax
movss  (%rax,%r15,4),%xmm4
jmp    1297 <updateMatrix+0x187>
nopw   0x0(%rax,%rax,1)
andps  %xmm10,%xmm0
xorpd  %xmm3,%xmm3
ucomisd %xmm8,%xmm0
xorpd  %xmm6,%xmm6
ja     1506 <updateMatrix+0x3f6>
movaps %xmm14,%xmm0
mulsd  %xmm14,%xmm0
divsd  %xmm15,%xmm0
movapd %xmm7,%xmm2
subsd  %xmm0,%xmm2
movapd %xmm2,%xmm6
mulsd  %xmm9,%xmm6
mulsd  %xmm2,%xmm6
movaps %xmm12,%xmm0
andps  %xmm10,%xmm0
ucomisd %xmm8,%xmm0
ja     1538 <updateMatrix+0x428>
movaps %xmm12,%xmm0
mulsd  %xmm12,%xmm0
divsd  %xmm15,%xmm0
movapd %xmm7,%xmm2
subsd  %xmm0,%xmm2
movapd %xmm2,%xmm3
mulsd  %xmm9,%xmm3
mulsd  %xmm2,%xmm3
movaps %xmm11,%xmm2
andps  %xmm10,%xmm2
xorpd  %xmm0,%xmm0
ucomisd %xmm8,%xmm2
xorpd  %xmm5,%xmm5
ja     1576 <updateMatrix+0x466>
movaps %xmm11,%xmm2
mulsd  %xmm11,%xmm2
divsd  %xmm15,%xmm2
movapd %xmm7,%xmm5
subsd  %xmm2,%xmm5
movapd %xmm5,%xmm2
mulsd  %xmm9,%xmm2
mulsd  %xmm5,%xmm2
movapd %xmm2,%xmm5
movaps %xmm13,%xmm2
andps  %xmm10,%xmm2
ucomisd %xmm8,%xmm2
ja     1297 <updateMatrix+0x187>
movaps %xmm13,%xmm0
mulsd  %xmm13,%xmm0
divsd  %xmm15,%xmm0
movapd %xmm7,%xmm2
subsd  %xmm0,%xmm2
movapd %xmm2,%xmm0
mulsd  %xmm9,%xmm0
mulsd  %xmm2,%xmm0
jmp    1297 <updateMatrix+0x187>
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @updateMatrix(float** %0, float** %1, i32 %2, i32 %3, i32 %4, double %5, double %6) {
%8 = alloca float**
%9 = alloca float**
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
store float** %0, float*** %8
store float** %1, float*** %9
store i32 %2, i32* %10
store i32 %3, i32* %11
store i32 %4, i32* %12
store double %5, double* %13
store double %6, double* %14
store double 5.000000e-01, double* %27
store double 2.500000e-01, double* %28
%36 = load double, double* %13
%37 = load double, double* %13
%38 = fmul double %36, %37
store double %38, double* %29
store i32 1, i32* %30
br label %39
39: ; preds = %354, %7
%40 = load i32, i32* %30
%41 = load i32, i32* %10
%42 = add nsw i32 %41, 1
%43 = icmp slt i32 %40, %42
br i1 %43, label %44, label %357
44: ; preds = %39
%45 = load i32, i32* %30
%46 = load i32, i32* %10
%47 = icmp eq i32 %45, %46
br i1 %47, label %48, label %50
48: ; preds = %44
%49 = load i32, i32* %10
br label %53
50: ; preds = %44
%51 = load i32, i32* %30
%52 = add nsw i32 %51, 1
br label %53
53: ; preds = %50, %48
%54 = phi i32 [ %49, %48 ], [ %52, %50 ]
store i32 %54, i32* %32
%55 = load i32, i32* %30
%56 = icmp eq i32 %55, 1
br i1 %56, label %57, label %58
57: ; preds = %53
br label %61
58: ; preds = %53
%59 = load i32, i32* %30
%60 = sub nsw i32 %59, 1
br label %61
61: ; preds = %58, %57
%62 = phi i32 [ 1, %57 ], [ %60, %58 ]
store i32 %62, i32* %33
store i32 1, i32* %31
br label %63
63: ; preds = %350, %61
%64 = load i32, i32* %31
%65 = load i32, i32* %11
%66 = add nsw i32 %65, 1
%67 = icmp slt i32 %64, %66
br i1 %67, label %68, label %353
68: ; preds = %63
%69 = load i32, i32* %31
%70 = load i32, i32* %11
%71 = icmp eq i32 %69, %70
br i1 %71, label %72, label %74
72: ; preds = %68
%73 = load i32, i32* %11
br label %77
74: ; preds = %68
%75 = load i32, i32* %31
%76 = add nsw i32 %75, 1
br label %77
77: ; preds = %74, %72
%78 = phi i32 [ %73, %72 ], [ %76, %74 ]
store i32 %78, i32* %34
%79 = load i32, i32* %31
%80 = icmp eq i32 %79, 1
br i1 %80, label %81, label %82
81: ; preds = %77
br label %85
82: ; preds = %77
%83 = load i32, i32* %31
%84 = sub nsw i32 %83, 1
br label %85
85: ; preds = %82, %81
%86 = phi i32 [ 1, %81 ], [ %84, %82 ]
store i32 %86, i32* %35
%87 = load float**, float*** %9
%88 = load i32, i32* %33
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds float*, float** %87, i64 %89
%91 = load float*, float** %90
%92 = load i32, i32* %31
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds float, float* %91, i64 %93
%95 = load float, float* %94
%96 = load float**, float*** %9
%97 = load i32, i32* %30
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds float*, float** %96, i64 %98
%100 = load float*, float** %99
%101 = load i32, i32* %31
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds float, float* %100, i64 %102
%104 = load float, float* %103
%105 = fsub float %95, %104
%106 = fpext float %105 to double
store double %106, double* %15
store double %106, double* %23
%107 = load float**, float*** %9
%108 = load i32, i32* %32
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds float*, float** %107, i64 %109
%111 = load float*, float** %110
%112 = load i32, i32* %31
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds float, float* %111, i64 %113
%115 = load float, float* %114
%116 = load float**, float*** %9
%117 = load i32, i32* %30
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds float*, float** %116, i64 %118
%120 = load float*, float** %119
%121 = load i32, i32* %31
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds float, float* %120, i64 %122
%124 = load float, float* %123
%125 = fsub float %115, %124
%126 = fpext float %125 to double
store double %126, double* %16
store double %126, double* %24
%127 = load float**, float*** %9
%128 = load i32, i32* %30
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds float*, float** %127, i64 %129
%131 = load float*, float** %130
%132 = load i32, i32* %34
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds float, float* %131, i64 %133
%135 = load float, float* %134
%136 = load float**, float*** %9
%137 = load i32, i32* %30
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds float*, float** %136, i64 %138
%140 = load float*, float** %139
%141 = load i32, i32* %31
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds float, float* %140, i64 %142
%144 = load float, float* %143
%145 = fsub float %135, %144
%146 = fpext float %145 to double
store double %146, double* %17
store double %146, double* %25
%147 = load float**, float*** %9
%148 = load i32, i32* %30
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds float*, float** %147, i64 %149
%151 = load float*, float** %150
%152 = load i32, i32* %35
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds float, float* %151, i64 %153
%155 = load float, float* %154
%156 = load float**, float*** %9
%157 = load i32, i32* %30
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds float*, float** %156, i64 %158
%160 = load float*, float** %159
%161 = load i32, i32* %31
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds float, float* %160, i64 %162
%164 = load float, float* %163
%165 = fsub float %155, %164
%166 = fpext float %165 to double
store double %166, double* %18
store double %166, double* %26
%167 = load i32, i32* %12
%168 = icmp eq i32 %167, 1
br i1 %168, label %169, label %198
169: ; preds = %85
%170 = load double, double* %23
%171 = fneg double %170
%172 = load double, double* %23
%173 = fmul double %171, %172
%174 = load double, double* %29
%175 = fdiv double %173, %174
%176 = call double @exp(double %175)
store double %176, double* %19
%177 = load double, double* %24
%178 = fneg double %177
%179 = load double, double* %24
%180 = fmul double %178, %179
%181 = load double, double* %29
%182 = fdiv double %180, %181
%183 = call double @exp(double %182)
store double %183, double* %20
%184 = load double, double* %25
%185 = fneg double %184
%186 = load double, double* %25
%187 = fmul double %185, %186
%188 = load double, double* %29
%189 = fdiv double %187, %188
%190 = call double @exp(double %189)
store double %190, double* %21
%191 = load double, double* %26
%192 = fneg double %191
%193 = load double, double* %26
%194 = fmul double %192, %193
%195 = load double, double* %29
%196 = fdiv double %194, %195
%197 = call double @exp(double %196)
store double %197, double* %22
br label %316
198: ; preds = %85
%199 = load i32, i32* %12
%200 = icmp eq i32 %199, 2
br i1 %200, label %201, label %230
201: ; preds = %198
%202 = load double, double* %23
%203 = load double, double* %23
%204 = fmul double %202, %203
%205 = load double, double* %29
%206 = fdiv double %204, %205
%207 = fadd double 1.000000e+00, %206
%208 = fdiv double 1.000000e+00, %207
store double %208, double* %19
%209 = load double, double* %24
%210 = load double, double* %24
%211 = fmul double %209, %210
%212 = load double, double* %29
%213 = fdiv double %211, %212
%214 = fadd double 1.000000e+00, %213
%215 = fdiv double 1.000000e+00, %214
store double %215, double* %20
%216 = load double, double* %25
%217 = load double, double* %25
%218 = fmul double %216, %217
%219 = load double, double* %29
%220 = fdiv double %218, %219
%221 = fadd double 1.000000e+00, %220
%222 = fdiv double 1.000000e+00, %221
store double %222, double* %21
%223 = load double, double* %26
%224 = load double, double* %26
%225 = fmul double %223, %224
%226 = load double, double* %29
%227 = fdiv double %225, %226
%228 = fadd double 1.000000e+00, %227
%229 = fdiv double 1.000000e+00, %228
store double %229, double* %22
br label %315
230: ; preds = %198
%231 = load double, double* %15
%232 = call double @llvm.fabs.f64(double %231)
%233 = load double, double* %13
%234 = fcmp ogt double %232, %233
br i1 %234, label %235, label %236
235: ; preds = %230
store double 0.000000e+00, double* %19
br label %251
236: ; preds = %230
%237 = load double, double* %23
%238 = load double, double* %23
%239 = fmul double %237, %238
%240 = load double, double* %29
%241 = fdiv double %239, %240
%242 = fsub double 1.000000e+00, %241
%243 = fmul double 5.000000e-01, %242
%244 = load double, double* %23
%245 = load double, double* %23
%246 = fmul double %244, %245
%247 = load double, double* %29
%248 = fdiv double %246, %247
%249 = fsub double 1.000000e+00, %248
%250 = fmul double %243, %249
store double %250, double* %19
br label %251
251: ; preds = %236, %235
%252 = load double, double* %16
%253 = call double @llvm.fabs.f64(double %252)
%254 = load double, double* %13
%255 = fcmp ogt double %253, %254
br i1 %255, label %256, label %257
256: ; preds = %251
store double 0.000000e+00, double* %20
br label %272
257: ; preds = %251
%258 = load double, double* %24
%259 = load double, double* %24
%260 = fmul double %258, %259
%261 = load double, double* %29
%262 = fdiv double %260, %261
%263 = fsub double 1.000000e+00, %262
%264 = fmul double 5.000000e-01, %263
%265 = load double, double* %24
%266 = load double, double* %24
%267 = fmul double %265, %266
%268 = load double, double* %29
%269 = fdiv double %267, %268
%270 = fsub double 1.000000e+00, %269
%271 = fmul double %264, %270
store double %271, double* %20
br label %272
272: ; preds = %257, %256
%273 = load double, double* %17
%274 = call double @llvm.fabs.f64(double %273)
%275 = load double, double* %13
%276 = fcmp ogt double %274, %275
br i1 %276, label %277, label %278
277: ; preds = %272
store double 0.000000e+00, double* %21
br label %293
278: ; preds = %272
%279 = load double, double* %25
%280 = load double, double* %25
%281 = fmul double %279, %280
%282 = load double, double* %29
%283 = fdiv double %281, %282
%284 = fsub double 1.000000e+00, %283
%285 = fmul double 5.000000e-01, %284
%286 = load double, double* %25
%287 = load double, double* %25
%288 = fmul double %286, %287
%289 = load double, double* %29
%290 = fdiv double %288, %289
%291 = fsub double 1.000000e+00, %290
%292 = fmul double %285, %291
store double %292, double* %21
br label %293
293: ; preds = %278, %277
%294 = load double, double* %18
%295 = call double @llvm.fabs.f64(double %294)
%296 = load double, double* %13
%297 = fcmp ogt double %295, %296
br i1 %297, label %298, label %299
298: ; preds = %293
store double 0.000000e+00, double* %22
br label %314
299: ; preds = %293
%300 = load double, double* %26
%301 = load double, double* %26
%302 = fmul double %300, %301
%303 = load double, double* %29
%304 = fdiv double %302, %303
%305 = fsub double 1.000000e+00, %304
%306 = fmul double 5.000000e-01, %305
%307 = load double, double* %26
%308 = load double, double* %26
%309 = fmul double %307, %308
%310 = load double, double* %29
%311 = fdiv double %309, %310
%312 = fsub double 1.000000e+00, %311
%313 = fmul double %306, %312
store double %313, double* %22
br label %314
314: ; preds = %299, %298
br label %315
315: ; preds = %314, %201
br label %316
316: ; preds = %315, %169
%317 = load float**, float*** %9
%318 = load i32, i32* %30
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds float*, float** %317, i64 %319
%321 = load float*, float** %320
%322 = load i32, i32* %31
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds float, float* %321, i64 %323
%325 = load float, float* %324
%326 = fpext float %325 to double
%327 = load double, double* %14
%328 = load double, double* %19
%329 = load double, double* %15
%330 = load double, double* %20
%331 = load double, double* %16
%332 = fmul double %330, %331
%333 = call double @llvm.fmuladd.f64(double %328, double %329, double %332)
%334 = load double, double* %21
%335 = load double, double* %17
%336 = call double @llvm.fmuladd.f64(double %334, double %335, double %333)
%337 = load double, double* %22
%338 = load double, double* %18
%339 = call double @llvm.fmuladd.f64(double %337, double %338, double %336)
%340 = call double @llvm.fmuladd.f64(double %327, double %339, double %326)
%341 = fptrunc double %340 to float
%342 = load float**, float*** %8
%343 = load i32, i32* %30
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds float*, float** %342, i64 %344
%346 = load float*, float** %345
%347 = load i32, i32* %31
%348 = sext i32 %347 to i64
%349 = getelementptr inbounds float, float* %346, i64 %348
store float %341, float* %349
br label %350
350: ; preds = %316
%351 = load i32, i32* %31
%352 = add nsw i32 %351, 1
store i32 %352, i32* %31
br label %63
353: ; preds = %63
br label %354
354: ; preds = %353
%355 = load i32, i32* %30
%356 = add nsw i32 %355, 1
store i32 %356, i32* %30
br label %39
357: ; preds = %39
ret void
}

LLVM IR (-O2):
define void @updateMatrix(float** nocapture %0, float** nocapture %1, i32 %2, i32 %3, i32 %4, double %5, double %6) {
%8 = fmul double %5, %5
%9 = icmp slt i32 %2, 1
br i1 %9, label %164, label %10
10: ; preds = %7
%11 = icmp slt i32 %3, 1
%12 = zext i32 %3 to i64
%13 = add i32 %3, 1
%14 = zext i32 %2 to i64
%15 = add nuw i32 %2, 1
%16 = zext i32 %15 to i64
%17 = zext i32 %13 to i64
br label %20
18: ; preds = %147, %20
%19 = icmp eq i64 %22, %16
br i1 %19, label %164, label %20
20: ; preds = %10, %18
%21 = phi i64 [ 1, %10 ], [ %22, %18 ]
%22 = add nuw nsw i64 %21, 1
br i1 %11, label %18, label %23
23: ; preds = %20
%24 = icmp eq i64 %21, 1
%25 = icmp eq i64 %21, %14
%26 = trunc i64 %22 to i32
%27 = select i1 %25, i32 %2, i32 %26
%28 = shl i64 %21, 32
%29 = add i64 %28, -4294967296
%30 = ashr exact i64 %29, 32
%31 = select i1 %24, i64 1, i64 %30
%32 = getelementptr inbounds float*, float** %1, i64 %31
%33 = getelementptr inbounds float*, float** %1, i64 %21
%34 = sext i32 %27 to i64
%35 = getelementptr inbounds float*, float** %1, i64 %34
%36 = getelementptr inbounds float*, float** %0, i64 %21
%37 = load float*, float** %33
br label %38
38: ; preds = %23, %147
%39 = phi float* [ %37, %23 ], [ %149, %147 ]
%40 = phi i64 [ 1, %23 ], [ %42, %147 ]
%41 = icmp eq i64 %40, %12
%42 = add nuw nsw i64 %40, 1
%43 = trunc i64 %42 to i32
%44 = select i1 %41, i32 %3, i32 %43
%45 = icmp eq i64 %40, 1
%46 = load float*, float** %32
%47 = getelementptr inbounds float, float* %46, i64 %40
%48 = load float, float* %47
%49 = getelementptr inbounds float, float* %39, i64 %40
%50 = load float, float* %49
%51 = fsub float %48, %50
%52 = fpext float %51 to double
%53 = load float*, float** %35
%54 = getelementptr inbounds float, float* %53, i64 %40
%55 = load float, float* %54
%56 = fsub float %55, %50
%57 = fpext float %56 to double
%58 = sext i32 %44 to i64
%59 = getelementptr inbounds float, float* %39, i64 %58
%60 = load float, float* %59
%61 = fsub float %60, %50
%62 = fpext float %61 to double
%63 = shl i64 %40, 32
%64 = add i64 %63, -4294967296
%65 = ashr exact i64 %64, 32
%66 = select i1 %45, i64 1, i64 %65
%67 = getelementptr inbounds float, float* %39, i64 %66
%68 = load float, float* %67
%69 = fsub float %68, %50
%70 = fpext float %69 to double
switch i32 %4, label %108 [
i32 1, label %71
i32 2, label %91
]
71: ; preds = %38
%72 = fneg double %52
%73 = fmul double %72, %52
%74 = fdiv double %73, %8
%75 = tail call double @exp(double %74)
%76 = fneg double %57
%77 = fmul double %76, %57
%78 = fdiv double %77, %8
%79 = tail call double @exp(double %78)
%80 = fneg double %62
%81 = fmul double %80, %62
%82 = fdiv double %81, %8
%83 = tail call double @exp(double %82)
%84 = fneg double %70
%85 = fmul double %84, %70
%86 = fdiv double %85, %8
%87 = tail call double @exp(double %86)
%88 = load float*, float** %33
%89 = getelementptr inbounds float, float* %88, i64 %40
%90 = load float, float* %89
br label %147
91: ; preds = %38
%92 = fmul double %52, %52
%93 = fdiv double %92, %8
%94 = fadd double %93, 1.000000e+00
%95 = fdiv double 1.000000e+00, %94
%96 = fmul double %57, %57
%97 = fdiv double %96, %8
%98 = fadd double %97, 1.000000e+00
%99 = fdiv double 1.000000e+00, %98
%100 = fmul double %62, %62
%101 = fdiv double %100, %8
%102 = fadd double %101, 1.000000e+00
%103 = fdiv double 1.000000e+00, %102
%104 = fmul double %70, %70
%105 = fdiv double %104, %8
%106 = fadd double %105, 1.000000e+00
%107 = fdiv double 1.000000e+00, %106
br label %147
108: ; preds = %38
%109 = tail call double @llvm.fabs.f64(double %52)
%110 = fcmp ogt double %109, %5
br i1 %110, label %117, label %111
111: ; preds = %108
%112 = fmul double %52, %52
%113 = fdiv double %112, %8
%114 = fsub double 1.000000e+00, %113
%115 = fmul double %114, 5.000000e-01
%116 = fmul double %114, %115
br label %117
117: ; preds = %108, %111
%118 = phi double [ %116, %111 ], [ 0.000000e+00, %108 ]
%119 = tail call double @llvm.fabs.f64(double %57)
%120 = fcmp ogt double %119, %5
br i1 %120, label %127, label %121
121: ; preds = %117
%122 = fmul double %57, %57
%123 = fdiv double %122, %8
%124 = fsub double 1.000000e+00, %123
%125 = fmul double %124, 5.000000e-01
%126 = fmul double %124, %125
br label %127
127: ; preds = %117, %121
%128 = phi double [ %126, %121 ], [ 0.000000e+00, %117 ]
%129 = tail call double @llvm.fabs.f64(double %62)
%130 = fcmp ogt double %129, %5
br i1 %130, label %137, label %131
131: ; preds = %127
%132 = fmul double %62, %62
%133 = fdiv double %132, %8
%134 = fsub double 1.000000e+00, %133
%135 = fmul double %134, 5.000000e-01
%136 = fmul double %134, %135
br label %137
137: ; preds = %127, %131
%138 = phi double [ %136, %131 ], [ 0.000000e+00, %127 ]
%139 = tail call double @llvm.fabs.f64(double %70)
%140 = fcmp ogt double %139, %5
br i1 %140, label %147, label %141
141: ; preds = %137
%142 = fmul double %70, %70
%143 = fdiv double %142, %8
%144 = fsub double 1.000000e+00, %143
%145 = fmul double %144, 5.000000e-01
%146 = fmul double %144, %145
br label %147
147: ; preds = %137, %91, %141, %71
%148 = phi float [ %90, %71 ], [ %50, %91 ], [ %50, %141 ], [ %50, %137 ]
%149 = phi float* [ %88, %71 ], [ %39, %91 ], [ %39, %141 ], [ %39, %137 ]
%150 = phi double [ %87, %71 ], [ %107, %91 ], [ %146, %141 ], [ 0.000000e+00, %137 ]
%151 = phi double [ %83, %71 ], [ %103, %91 ], [ %138, %141 ], [ %138, %137 ]
%152 = phi double [ %79, %71 ], [ %99, %91 ], [ %128, %141 ], [ %128, %137 ]
%153 = phi double [ %75, %71 ], [ %95, %91 ], [ %118, %141 ], [ %118, %137 ]
%154 = fpext float %148 to double
%155 = fmul double %152, %57
%156 = tail call double @llvm.fmuladd.f64(double %153, double %52, double %155)
%157 = tail call double @llvm.fmuladd.f64(double %151, double %62, double %156)
%158 = tail call double @llvm.fmuladd.f64(double %150, double %70, double %157)
%159 = tail call double @llvm.fmuladd.f64(double %6, double %158, double %154)
%160 = fptrunc double %159 to float
%161 = load float*, float** %36
%162 = getelementptr inbounds float, float* %161, i64 %40
store float %160, float* %162
%163 = icmp eq i64 %42, %17
br i1 %163, label %18, label %38
164: ; preds = %18, %7
ret void
}