double bdr(const double ref_psnr[4], const double new_psnr[4],
           const double ref_bitrate[4], const double new_bitrate[4]) {
  double xl, xh;
  double diff;
  double E[4], F[4], G[4], H[4];
  double SUM[2];
  int i, j;
  double DET0, DET1, DET2, DET3, DET;
  double D0, D1, D2, D3;
  double A, B, C, D;
  double X[2][4];
  double Y[2][4];
  for (i = 0; i < 4; i++) {
    X[0][i] = ref_psnr[i];
    X[1][i] = new_psnr[i];
    Y[0][i] = log(ref_bitrate[i]);
    Y[1][i] = log(new_bitrate[i]);
  }
  xl = ((X[0][0]) > (X[1][0]) ? (X[0][0]) : (X[1][0]));
  xh = ((X[0][3]) < (X[1][3]) ? (X[0][3]) : (X[1][3]));
  for (j = 0; j < 2; j++) {
    for (i = 0; i < 4; i++) {
      E[i] = X[j][i];
      F[i] = E[i] * E[i];
      G[i] = E[i] * E[i] * E[i];
      H[i] = Y[j][i];
    }
    DET0 = E[1] * (F[2] * G[3] - F[3] * G[2]) -
           E[2] * (F[1] * G[3] - F[3] * G[1]) +
           E[3] * (F[1] * G[2] - F[2] * G[1]);
    DET1 = -E[0] * (F[2] * G[3] - F[3] * G[2]) +
           E[2] * (F[0] * G[3] - F[3] * G[0]) -
           E[3] * (F[0] * G[2] - F[2] * G[0]);
    DET2 = E[0] * (F[1] * G[3] - F[3] * G[1]) -
           E[1] * (F[0] * G[3] - F[3] * G[0]) +
           E[3] * (F[0] * G[1] - F[1] * G[0]);
    DET3 = -E[0] * (F[1] * G[2] - F[2] * G[1]) +
           E[1] * (F[0] * G[2] - F[2] * G[0]) -
           E[2] * (F[0] * G[1] - F[1] * G[0]);
    DET = DET0 + DET1 + DET2 + DET3;
    D0 = H[0] * DET0 + H[1] * DET1 + H[2] * DET2 + H[3] * DET3;
    D1 = H[1] * (F[2] * G[3] - F[3] * G[2]) -
         H[2] * (F[1] * G[3] - F[3] * G[1]) +
         H[3] * (F[1] * G[2] - F[2] * G[1]) -
         H[0] * (F[2] * G[3] - F[3] * G[2]) +
         H[2] * (F[0] * G[3] - F[3] * G[0]) -
         H[3] * (F[0] * G[2] - F[2] * G[0]) +
         H[0] * (F[1] * G[3] - F[3] * G[1]) -
         H[1] * (F[0] * G[3] - F[3] * G[0]) +
         H[3] * (F[0] * G[1] - F[1] * G[0]) -
         H[0] * (F[1] * G[2] - F[2] * G[1]) +
         H[1] * (F[0] * G[2] - F[2] * G[0]) -
         H[2] * (F[0] * G[1] - F[1] * G[0]);
    D2 = E[1] * (H[2] * G[3] - H[3] * G[2]) -
         E[2] * (H[1] * G[3] - H[3] * G[1]) +
         E[3] * (H[1] * G[2] - H[2] * G[1]) -
         E[0] * (H[2] * G[3] - H[3] * G[2]) +
         E[2] * (H[0] * G[3] - H[3] * G[0]) -
         E[3] * (H[0] * G[2] - H[2] * G[0]) +
         E[0] * (H[1] * G[3] - H[3] * G[1]) -
         E[1] * (H[0] * G[3] - H[3] * G[0]) +
         E[3] * (H[0] * G[1] - H[1] * G[0]) -
         E[0] * (H[1] * G[2] - H[2] * G[1]) +
         E[1] * (H[0] * G[2] - H[2] * G[0]) -
         E[2] * (H[0] * G[1] - H[1] * G[0]);
    D3 = E[1] * (F[2] * H[3] - F[3] * H[2]) -
         E[2] * (F[1] * H[3] - F[3] * H[1]) +
         E[3] * (F[1] * H[2] - F[2] * H[1]) -
         E[0] * (F[2] * H[3] - F[3] * H[2]) +
         E[2] * (F[0] * H[3] - F[3] * H[0]) -
         E[3] * (F[0] * H[2] - F[2] * H[0]) +
         E[0] * (F[1] * H[3] - F[3] * H[1]) -
         E[1] * (F[0] * H[3] - F[3] * H[0]) +
         E[3] * (F[0] * H[1] - F[1] * H[0]) -
         E[0] * (F[1] * H[2] - F[2] * H[1]) +
         E[1] * (F[0] * H[2] - F[2] * H[0]) -
         E[2] * (F[0] * H[1] - F[1] * H[0]);
    A = D0 / DET;
    B = D1 / DET;
    C = D2 / DET;
    D = D3 / DET;
    SUM[j] = A * (xh - xl) + B * (xh * xh - xl * xl) / 2 +
             C * (xh * xh * xh - xl * xl * xl) / 3 +
             D * (xh * xh * xh * xh - xl * xl * xl * xl) / 4;
  }
  diff = (SUM[1] - SUM[0]) / (xh - xl);
  diff = (exp(diff) - 1) * 100;
  return diff;
}


x86 assembly (clang, -O0):
<bdr>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1d0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movl   $0x0,-0xd4(%rbp)
cmpl   $0x4,-0xd4(%rbp)
jge    11f0 <bdr+0xd0>
mov    -0x8(%rbp),%rax
movslq -0xd4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0xd4(%rbp),%rax
movsd  %xmm0,-0x180(%rbp,%rax,8)
ff ff
mov    -0x10(%rbp),%rax
movslq -0xd4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0xd4(%rbp),%rax
movsd  %xmm0,-0x160(%rbp,%rax,8)
ff ff
mov    -0x18(%rbp),%rax
movslq -0xd4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1040 <log@plt>
movslq -0xd4(%rbp),%rax
movsd  %xmm0,-0x1c0(%rbp,%rax,8)
ff ff
mov    -0x20(%rbp),%rax
movslq -0xd4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1040 <log@plt>
movslq -0xd4(%rbp),%rax
movsd  %xmm0,-0x1a0(%rbp,%rax,8)
ff ff
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    1145 <bdr+0x25>
movsd  -0x180(%rbp),%xmm0
ff
ucomisd -0x160(%rbp),%xmm0
ff
jbe    121b <bdr+0xfb>
movsd  -0x180(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c8(%rbp)
ff
jmp    122b <bdr+0x10b>
movsd  -0x160(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x1c8(%rbp),%xmm0
ff
movsd  %xmm0,-0x28(%rbp)
movsd  -0x168(%rbp),%xmm1
ff
movsd  -0x148(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1267 <bdr+0x147>
movsd  -0x168(%rbp),%xmm0
ff
movsd  %xmm0,-0x1d0(%rbp)
ff
jmp    1277 <bdr+0x157>
movsd  -0x148(%rbp),%xmm0
ff
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x1d0(%rbp),%xmm0
ff
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0xd8(%rbp)
cmpl   $0x2,-0xd8(%rbp)
jge    2580 <bdr+0x1460>
movl   $0x0,-0xd4(%rbp)
cmpl   $0x4,-0xd4(%rbp)
jge    1383 <bdr+0x263>
movslq -0xd8(%rbp),%rcx
lea    -0x180(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0xd4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0xd4(%rbp),%rax
movsd  %xmm0,-0x60(%rbp,%rax,8)
movslq -0xd4(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm0
movslq -0xd4(%rbp),%rax
mulsd  -0x60(%rbp,%rax,8),%xmm0
movslq -0xd4(%rbp),%rax
movsd  %xmm0,-0x80(%rbp,%rax,8)
movslq -0xd4(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm0
movslq -0xd4(%rbp),%rax
mulsd  -0x60(%rbp,%rax,8),%xmm0
movslq -0xd4(%rbp),%rax
mulsd  -0x60(%rbp,%rax,8),%xmm0
movslq -0xd4(%rbp),%rax
movsd  %xmm0,-0xa0(%rbp,%rax,8)
ff ff
movslq -0xd8(%rbp),%rcx
lea    -0x1c0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0xd4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0xd4(%rbp),%rax
movsd  %xmm0,-0xc0(%rbp,%rax,8)
ff ff
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    12a5 <bdr+0x185>
movsd  -0x58(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm3
ff
movsd  -0x68(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0x50(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm3
movsd  -0x88(%rbp),%xmm5
ff
movsd  -0x68(%rbp),%xmm4
mulsd  -0x98(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm4
ff
movsd  -0x70(%rbp),%xmm3
mulsd  -0x98(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0x70(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm3
ff
movsd  -0x68(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0x50(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm3
movsd  -0x88(%rbp),%xmm5
ff
movsd  -0x68(%rbp),%xmm4
mulsd  -0xa0(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm4
ff
movsd  -0x70(%rbp),%xmm3
mulsd  -0xa0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x60(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm3
ff
movsd  -0x68(%rbp),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0x58(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm3
movsd  -0x88(%rbp),%xmm5
ff
movsd  -0x68(%rbp),%xmm4
mulsd  -0xa0(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm4
ff
movsd  -0x78(%rbp),%xmm3
mulsd  -0xa0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0x78(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm3
ff
movsd  -0x70(%rbp),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0x58(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm3
movsd  -0x90(%rbp),%xmm5
ff
movsd  -0x70(%rbp),%xmm4
mulsd  -0xa0(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm4
ff
movsd  -0x78(%rbp),%xmm3
mulsd  -0xa0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
addsd  -0xe8(%rbp),%xmm0
ff
addsd  -0xf0(%rbp),%xmm0
ff
addsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  -0xe8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
movsd  -0xf0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm3
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm3
movsd  -0x88(%rbp),%xmm5
ff
movsd  -0x68(%rbp),%xmm4
mulsd  -0x98(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm4
ff
movsd  -0x70(%rbp),%xmm3
mulsd  -0x98(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm4
ff
movsd  -0x68(%rbp),%xmm3
mulsd  -0x90(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm4
ff
movsd  -0x68(%rbp),%xmm3
mulsd  -0xa0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm4
ff
movsd  -0x70(%rbp),%xmm3
mulsd  -0xa0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm4
ff
movsd  -0x68(%rbp),%xmm3
mulsd  -0x98(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm4
ff
movsd  -0x68(%rbp),%xmm3
mulsd  -0xa0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm4
ff
movsd  -0x78(%rbp),%xmm3
mulsd  -0xa0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm4
ff
movsd  -0x70(%rbp),%xmm3
mulsd  -0x98(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xb8(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm4
ff
movsd  -0x70(%rbp),%xmm3
mulsd  -0xa0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm4
ff
movsd  -0x78(%rbp),%xmm3
mulsd  -0xa0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm3
ff
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0x90(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x50(%rbp),%xmm1
movsd  -0xb8(%rbp),%xmm3
ff
movsd  -0x88(%rbp),%xmm5
ff
movsd  -0xa8(%rbp),%xmm4
ff
mulsd  -0x98(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x48(%rbp),%xmm1
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm4
ff
movsd  -0xb0(%rbp),%xmm3
ff
mulsd  -0x98(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm4
ff
movsd  -0xa8(%rbp),%xmm3
ff
mulsd  -0x90(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x50(%rbp),%xmm1
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm4
ff
movsd  -0xa8(%rbp),%xmm3
ff
mulsd  -0xa0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm4
ff
movsd  -0xb0(%rbp),%xmm3
ff
mulsd  -0xa0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x60(%rbp),%xmm1
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm4
ff
movsd  -0xa8(%rbp),%xmm3
ff
mulsd  -0x98(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x58(%rbp),%xmm0
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm4
ff
movsd  -0xa8(%rbp),%xmm3
ff
mulsd  -0xa0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x48(%rbp),%xmm1
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm4
ff
movsd  -0xb8(%rbp),%xmm3
ff
mulsd  -0xa0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm4
ff
movsd  -0xb0(%rbp),%xmm3
ff
mulsd  -0x98(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x58(%rbp),%xmm1
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm4
ff
movsd  -0xb0(%rbp),%xmm3
ff
mulsd  -0xa0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm4
ff
movsd  -0xb8(%rbp),%xmm3
ff
mulsd  -0xa0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0xa8(%rbp),%xmm3
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0xb0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x50(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm3
movsd  -0xa8(%rbp),%xmm5
ff
movsd  -0x68(%rbp),%xmm4
mulsd  -0xb8(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x48(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm2
movsd  -0xb0(%rbp),%xmm4
ff
movsd  -0x70(%rbp),%xmm3
mulsd  -0xb8(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0xa8(%rbp),%xmm4
ff
movsd  -0x68(%rbp),%xmm3
mulsd  -0xb0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x50(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm2
movsd  -0xa8(%rbp),%xmm4
ff
movsd  -0x68(%rbp),%xmm3
mulsd  -0xc0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0xb0(%rbp),%xmm4
ff
movsd  -0x70(%rbp),%xmm3
mulsd  -0xc0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x60(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm2
movsd  -0xa8(%rbp),%xmm4
ff
movsd  -0x68(%rbp),%xmm3
mulsd  -0xb8(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x58(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0xa8(%rbp),%xmm4
ff
movsd  -0x68(%rbp),%xmm3
mulsd  -0xc0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x48(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm2
movsd  -0xb8(%rbp),%xmm4
ff
movsd  -0x78(%rbp),%xmm3
mulsd  -0xc0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0xb0(%rbp),%xmm4
ff
movsd  -0x70(%rbp),%xmm3
mulsd  -0xb8(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x58(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm2
movsd  -0xb0(%rbp),%xmm4
ff
movsd  -0x70(%rbp),%xmm3
mulsd  -0xc0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0xb8(%rbp),%xmm4
ff
movsd  -0x78(%rbp),%xmm3
mulsd  -0xc0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
divsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
divsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
divsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
divsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0x30(%rbp),%xmm2
subsd  -0x28(%rbp),%xmm2
movsd  -0x130(%rbp),%xmm1
ff
movsd  -0x30(%rbp),%xmm3
movsd  -0x30(%rbp),%xmm5
movsd  -0x28(%rbp),%xmm4
mulsd  -0x28(%rbp),%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movsd  0xb8c(%rip),%xmm3
divsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x138(%rbp),%xmm1
ff
movsd  -0x30(%rbp),%xmm2
mulsd  -0x30(%rbp),%xmm2
movsd  -0x30(%rbp),%xmm4
movsd  -0x28(%rbp),%xmm3
mulsd  -0x28(%rbp),%xmm3
mulsd  -0x28(%rbp),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
movsd  0xb27(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  -0x140(%rbp),%xmm1
movsd  -0x30(%rbp),%xmm2
mulsd  -0x30(%rbp),%xmm2
mulsd  -0x30(%rbp),%xmm2
movsd  -0x30(%rbp),%xmm4
movsd  -0x28(%rbp),%xmm3
mulsd  -0x28(%rbp),%xmm3
mulsd  -0x28(%rbp),%xmm3
mulsd  -0x28(%rbp),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
movsd  0xabc(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movslq -0xd8(%rbp),%rax
movsd  %xmm0,-0xd0(%rbp,%rax,8)
ff ff
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    128e <bdr+0x16e>
movsd  -0xc8(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
movsd  -0x30(%rbp),%xmm1
subsd  -0x28(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
call   1030 <exp@plt>
movsd  0xa53(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0xa3f(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
add    $0x1d0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bdr>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    %rcx,%r14
mov    %rdx,%r15
mov    %rsi,%r12
mov    %rdi,%rbx
movsd  (%rdi),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  %xmm0,0xd0(%rsp)
movsd  (%rsi),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  %xmm0,0xf0(%rsp)
movsd  (%rdx),%xmm0
call   1040 <log@plt>
movsd  %xmm0,0x20(%rsp)
movsd  %xmm0,0x90(%rsp)
movsd  (%r14),%xmm0
call   1040 <log@plt>
movsd  %xmm0,0xb0(%rsp)
movsd  0x8(%rbx),%xmm0
movsd  %xmm0,0xd8(%rsp)
movsd  0x8(%r12),%xmm0
movsd  %xmm0,0xf8(%rsp)
movsd  0x8(%r15),%xmm0
call   1040 <log@plt>
movsd  %xmm0,0x98(%rsp)
movsd  0x8(%r14),%xmm0
call   1040 <log@plt>
movsd  %xmm0,0xb8(%rsp)
movsd  0x10(%rbx),%xmm0
movsd  %xmm0,0xe0(%rsp)
movsd  0x10(%r12),%xmm0
movsd  %xmm0,0x100(%rsp)
movsd  0x10(%r15),%xmm0
call   1040 <log@plt>
movsd  %xmm0,0xa0(%rsp)
movsd  0x10(%r14),%xmm0
call   1040 <log@plt>
movsd  %xmm0,0xc0(%rsp)
movsd  0x18(%rbx),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  %xmm0,0xe8(%rsp)
movsd  0x18(%r12),%xmm0
movsd  %xmm0,(%rsp)
movsd  %xmm0,0x108(%rsp)
movsd  0x18(%r15),%xmm0
call   1040 <log@plt>
movsd  %xmm0,0xa8(%rsp)
movsd  0x18(%r14),%xmm0
call   1040 <log@plt>
movsd  0x18(%rsp),%xmm1
movsd  %xmm0,0xc8(%rsp)
movapd %xmm1,%xmm14
movapd %xmm1,%xmm0
maxsd  0x10(%rsp),%xmm0
movsd  0x8(%rsp),%xmm4
minsd  (%rsp),%xmm4
movapd %xmm4,%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x28(%rsp)
movapd 0xd62(%rip),%xmm1
xorpd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm4,%xmm2
mulsd  %xmm4,%xmm2
movapd %xmm2,%xmm3
addsd  %xmm1,%xmm3
movsd  %xmm3,0x48(%rsp)
mulsd  %xmm0,%xmm1
mulsd  %xmm4,%xmm2
movapd %xmm2,%xmm3
addsd  %xmm1,%xmm3
movsd  %xmm3,0x40(%rsp)
mulsd  %xmm0,%xmm1
mulsd  %xmm4,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x50(%rsp)
mov    $0x1,%cl
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
mov    %rax,%rdx
shl    $0x5,%rdx
movsd  0xd8(%rsp,%rdx,1),%xmm0
movsd  0xe0(%rsp,%rdx,1),%xmm1
movsd  0xe8(%rsp,%rdx,1),%xmm2
movapd %xmm0,%xmm3
mulsd  %xmm0,%xmm3
movapd %xmm0,%xmm4
movapd %xmm0,%xmm10
movsd  %xmm0,(%rsp)
mulsd  %xmm3,%xmm4
movapd %xmm4,%xmm7
movsd  %xmm4,0x30(%rsp)
movapd %xmm1,%xmm0
mulsd  %xmm1,%xmm1
movapd %xmm0,%xmm8
movapd %xmm0,%xmm9
mulsd  %xmm1,%xmm8
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm2
movapd %xmm0,%xmm4
movapd %xmm0,%xmm13
mulsd  %xmm2,%xmm4
movapd %xmm8,%xmm0
mulsd  %xmm2,%xmm0
movapd %xmm1,%xmm6
movapd %xmm1,%xmm5
mulsd  %xmm4,%xmm6
subsd  %xmm0,%xmm6
movapd %xmm7,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm2,%xmm12
movsd  %xmm2,0x78(%rsp)
movapd %xmm3,%xmm0
mulsd  %xmm4,%xmm0
movsd  %xmm4,0x58(%rsp)
subsd  %xmm1,%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm9,%xmm1
movsd  %xmm9,0x8(%rsp)
movapd %xmm10,%xmm2
mulsd  %xmm6,%xmm2
subsd  %xmm1,%xmm2
movapd %xmm7,%xmm1
mulsd  %xmm5,%xmm1
movapd %xmm5,%xmm7
movsd  %xmm5,0x70(%rsp)
movapd %xmm3,%xmm5
movapd %xmm3,%xmm11
movsd  %xmm3,0x68(%rsp)
mulsd  %xmm8,%xmm5
subsd  %xmm1,%xmm5
movapd %xmm13,%xmm1
movapd %xmm13,%xmm10
mulsd  %xmm5,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x10(%rsp)
movapd %xmm14,%xmm15
mulsd  %xmm14,%xmm15
movapd %xmm14,%xmm2
mulsd  %xmm15,%xmm2
movapd %xmm2,%xmm1
movapd %xmm2,%xmm13
mulsd  %xmm12,%xmm1
movapd %xmm15,%xmm2
mulsd  %xmm4,%xmm2
subsd  %xmm1,%xmm2
movapd %xmm9,%xmm12
mulsd  %xmm2,%xmm12
movapd %xmm14,%xmm1
mulsd  %xmm6,%xmm1
subsd  %xmm1,%xmm12
movapd %xmm13,%xmm3
movapd %xmm13,%xmm9
movsd  %xmm13,0x60(%rsp)
mulsd  %xmm7,%xmm3
movapd %xmm15,%xmm1
movapd %xmm15,%xmm13
movsd  %xmm15,0x80(%rsp)
mulsd  %xmm8,%xmm1
subsd  %xmm3,%xmm1
movapd %xmm10,%xmm7
movsd  %xmm10,0x38(%rsp)
movapd %xmm10,%xmm3
mulsd  %xmm1,%xmm3
movapd %xmm1,%xmm15
subsd  %xmm3,%xmm12
movapd %xmm2,%xmm3
movsd  (%rsp),%xmm1
mulsd  %xmm1,%xmm3
movapd %xmm14,%xmm4
movapd %xmm14,%xmm10
movsd  %xmm14,0x18(%rsp)
mulsd  %xmm0,%xmm10
subsd  %xmm3,%xmm10
movapd %xmm9,%xmm14
mulsd  %xmm11,%xmm14
movapd %xmm13,%xmm3
movsd  0x30(%rsp),%xmm9
mulsd  %xmm9,%xmm3
subsd  %xmm14,%xmm3
movapd %xmm7,%xmm14
mulsd  %xmm3,%xmm14
addsd  %xmm10,%xmm14
movapd %xmm1,%xmm7
movapd %xmm1,%xmm13
mulsd  %xmm15,%xmm7
mulsd  %xmm5,%xmm4
subsd  %xmm4,%xmm7
movsd  0x8(%rsp),%xmm1
mulsd  %xmm3,%xmm1
subsd  %xmm1,%xmm7
movsd  0x20(%rsp),%xmm1
movapd %xmm1,%xmm10
movapd %xmm1,%xmm4
movsd  0x10(%rsp),%xmm1
mulsd  %xmm1,%xmm10
addsd  %xmm12,%xmm1
movsd  0x98(%rsp,%rdx,1),%xmm11
mulsd  %xmm11,%xmm12
addsd  %xmm10,%xmm12
addsd  %xmm14,%xmm1
movsd  0xa0(%rsp,%rdx,1),%xmm10
mulsd  %xmm10,%xmm14
addsd  %xmm12,%xmm14
addsd  %xmm7,%xmm1
movsd  %xmm1,0x10(%rsp)
movsd  0xa8(%rsp,%rdx,1),%xmm12
mulsd  %xmm12,%xmm7
addsd  %xmm14,%xmm7
movsd  %xmm7,0x88(%rsp)
movapd %xmm4,%xmm14
mulsd  %xmm0,%xmm14
mulsd  %xmm10,%xmm0
movapd %xmm11,%xmm1
mulsd  %xmm6,%xmm1
subsd  %xmm0,%xmm1
movapd %xmm12,%xmm0
mulsd  %xmm5,%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm4,%xmm6
movsd  %xmm4,0x20(%rsp)
subsd  %xmm6,%xmm0
movapd %xmm10,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm12,%xmm0
mulsd  %xmm15,%xmm0
subsd  %xmm0,%xmm1
addsd  %xmm14,%xmm1
mulsd  %xmm11,%xmm2
subsd  %xmm2,%xmm1
movapd %xmm12,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm4,%xmm5
subsd  %xmm5,%xmm0
mulsd  %xmm11,%xmm15
movapd %xmm11,%xmm14
addsd  %xmm0,%xmm15
mulsd  %xmm10,%xmm3
subsd  %xmm3,%xmm15
movapd %xmm8,%xmm0
mulsd  %xmm12,%xmm0
movapd %xmm10,%xmm1
movsd  0x58(%rsp),%xmm7
mulsd  %xmm7,%xmm1
subsd  %xmm0,%xmm1
movapd %xmm9,%xmm2
mulsd  %xmm12,%xmm2
movapd %xmm11,%xmm0
mulsd  %xmm7,%xmm0
subsd  %xmm2,%xmm0
movapd %xmm0,%xmm2
movsd  0x8(%rsp),%xmm6
mulsd  %xmm6,%xmm2
mulsd  %xmm1,%xmm13
subsd  %xmm2,%xmm13
mulsd  %xmm10,%xmm9
movapd %xmm11,%xmm2
mulsd  %xmm8,%xmm2
subsd  %xmm9,%xmm2
movsd  0x38(%rsp),%xmm9
movapd %xmm9,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm13,%xmm5
movsd  0x18(%rsp),%xmm13
mulsd  %xmm13,%xmm1
subsd  %xmm1,%xmm5
movsd  0x60(%rsp),%xmm4
movapd %xmm4,%xmm1
mulsd  %xmm12,%xmm1
movsd  0x20(%rsp),%xmm11
movapd %xmm7,%xmm3
mulsd  %xmm11,%xmm3
subsd  %xmm1,%xmm3
movapd %xmm6,%xmm1
mulsd  %xmm3,%xmm1
movapd %xmm3,%xmm7
addsd  %xmm5,%xmm1
movapd %xmm4,%xmm3
mulsd  %xmm10,%xmm3
mulsd  %xmm11,%xmm8
subsd  %xmm3,%xmm8
movapd %xmm9,%xmm5
movapd %xmm9,%xmm3
mulsd  %xmm8,%xmm3
subsd  %xmm3,%xmm1
mulsd  %xmm13,%xmm0
addsd  %xmm1,%xmm0
movsd  (%rsp),%xmm6
mulsd  %xmm6,%xmm7
subsd  %xmm7,%xmm0
movapd %xmm4,%xmm1
mulsd  %xmm14,%xmm1
movsd  0x30(%rsp),%xmm4
mulsd  %xmm11,%xmm4
subsd  %xmm1,%xmm4
movapd %xmm9,%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm13,%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm6,%xmm8
addsd  %xmm1,%xmm8
movsd  0x8(%rsp),%xmm7
mulsd  %xmm7,%xmm4
subsd  %xmm4,%xmm8
movapd %xmm10,%xmm1
movsd  0x78(%rsp),%xmm0
mulsd  %xmm0,%xmm1
movsd  0x70(%rsp),%xmm4
movapd %xmm4,%xmm9
mulsd  %xmm12,%xmm9
subsd  %xmm1,%xmm9
movapd %xmm14,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm0,%xmm3
movsd  0x68(%rsp),%xmm0
movapd %xmm0,%xmm2
mulsd  %xmm12,%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm11,%xmm3
movsd  0x80(%rsp),%xmm1
mulsd  %xmm1,%xmm12
subsd  %xmm3,%xmm12
movapd %xmm0,%xmm3
movapd %xmm0,%xmm5
mulsd  %xmm10,%xmm3
mulsd  %xmm1,%xmm10
mulsd  %xmm14,%xmm1
movapd %xmm14,%xmm13
movapd %xmm4,%xmm0
mulsd  %xmm4,%xmm13
mulsd  %xmm11,%xmm0
subsd  %xmm0,%xmm10
movapd %xmm5,%xmm0
mulsd  %xmm11,%xmm0
subsd  %xmm0,%xmm1
movapd %xmm2,%xmm4
mulsd  %xmm7,%xmm4
movsd  0x38(%rsp),%xmm0
movapd %xmm0,%xmm5
movapd %xmm0,%xmm14
mulsd  %xmm1,%xmm0
movapd %xmm0,%xmm6
movapd %xmm7,%xmm0
mulsd  %xmm7,%xmm1
movapd %xmm1,%xmm7
mulsd  %xmm12,%xmm0
movsd  (%rsp),%xmm1
mulsd  %xmm1,%xmm12
mulsd  %xmm10,%xmm14
mulsd  %xmm1,%xmm10
mulsd  %xmm9,%xmm1
subsd  %xmm4,%xmm1
subsd  %xmm13,%xmm3
mulsd  %xmm3,%xmm5
addsd  %xmm1,%xmm5
movsd  0x18(%rsp),%xmm1
mulsd  %xmm1,%xmm9
subsd  %xmm9,%xmm5
addsd  %xmm5,%xmm0
subsd  %xmm14,%xmm0
mulsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
subsd  %xmm12,%xmm2
addsd  %xmm2,%xmm6
mulsd  %xmm1,%xmm3
subsd  %xmm3,%xmm6
addsd  %xmm6,%xmm10
subsd  %xmm7,%xmm10
movsd  0x10(%rsp),%xmm0
movsd  0x88(%rsp),%xmm1
divsd  %xmm0,%xmm1
divsd  %xmm0,%xmm15
divsd  %xmm0,%xmm8
divsd  %xmm0,%xmm10
mulsd  0x48(%rsp),%xmm15
mulsd  0x762(%rip),%xmm15
movapd %xmm1,%xmm0
mulsd  0x28(%rsp),%xmm0
addsd  %xmm15,%xmm0
mulsd  0x40(%rsp),%xmm8
divsd  0x74b(%rip),%xmm8
addsd  %xmm0,%xmm8
mulsd  0x50(%rsp),%xmm10
mulsd  0x73e(%rip),%xmm10
addsd  %xmm8,%xmm10
movsd  %xmm10,0x110(%rsp,%rax,8)
test   $0x1,%cl
je     1923 <bdr+0x803>
add    $0x1,%rax
shl    $0x5,%rax
movsd  0xd0(%rsp,%rax,1),%xmm14
movsd  0x90(%rsp,%rax,1),%xmm0
movsd  %xmm0,0x20(%rsp)
mov    $0x1,%eax
xor    %ecx,%ecx
jmp    12f0 <bdr+0x1d0>
movsd  0x118(%rsp),%xmm0
subsd  0x110(%rsp),%xmm0
divsd  0x28(%rsp),%xmm0
call   1030 <exp@plt>
addsd  0x6e0(%rip),%xmm0
mulsd  0x6e0(%rip),%xmm0
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define double @bdr(double* %0, double* %1, double* %2, double* %3) {
%5 = alloca double*
%6 = alloca double*
%7 = alloca double*
%8 = alloca double*
%9 = alloca double
%10 = alloca double
%11 = alloca double
%12 = alloca [4 x double]
%13 = alloca [4 x double]
%14 = alloca [4 x double]
%15 = alloca [4 x double]
%16 = alloca [2 x double]
%17 = alloca i32
%18 = alloca i32
%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 double
%31 = alloca double
%32 = alloca [2 x [4 x double]]
%33 = alloca [2 x [4 x double]]
store double* %0, double** %5
store double* %1, double** %6
store double* %2, double** %7
store double* %3, double** %8
store i32 0, i32* %17
br label %34
34: ; preds = %76, %4
%35 = load i32, i32* %17
%36 = icmp slt i32 %35, 4
br i1 %36, label %37, label %79
37: ; preds = %34
%38 = load double*, double** %5
%39 = load i32, i32* %17
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds double, double* %38, i64 %40
%42 = load double, double* %41
%43 = getelementptr inbounds [2 x [4 x double]], [2 x [4 x double]]* %32, i64 0, i64 0
%44 = load i32, i32* %17
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds [4 x double], [4 x double]* %43, i64 0, i64 %45
store double %42, double* %46
%47 = load double*, double** %6
%48 = load i32, i32* %17
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds double, double* %47, i64 %49
%51 = load double, double* %50
%52 = getelementptr inbounds [2 x [4 x double]], [2 x [4 x double]]* %32, i64 0, i64 1
%53 = load i32, i32* %17
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds [4 x double], [4 x double]* %52, i64 0, i64 %54
store double %51, double* %55
%56 = load double*, double** %7
%57 = load i32, i32* %17
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds double, double* %56, i64 %58
%60 = load double, double* %59
%61 = call double @log(double %60)
%62 = getelementptr inbounds [2 x [4 x double]], [2 x [4 x double]]* %33, i64 0, i64 0
%63 = load i32, i32* %17
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds [4 x double], [4 x double]* %62, i64 0, i64 %64
store double %61, double* %65
%66 = load double*, double** %8
%67 = load i32, i32* %17
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds double, double* %66, i64 %68
%70 = load double, double* %69
%71 = call double @log(double %70)
%72 = getelementptr inbounds [2 x [4 x double]], [2 x [4 x double]]* %33, i64 0, i64 1
%73 = load i32, i32* %17
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [4 x double], [4 x double]* %72, i64 0, i64 %74
store double %71, double* %75
br label %76
76: ; preds = %37
%77 = load i32, i32* %17
%78 = add nsw i32 %77, 1
store i32 %78, i32* %17
br label %34
79: ; preds = %34
%80 = getelementptr inbounds [2 x [4 x double]], [2 x [4 x double]]* %32, i64 0, i64 0
%81 = getelementptr inbounds [4 x double], [4 x double]* %80, i64 0, i64 0
%82 = load double, double* %81
%83 = getelementptr inbounds [2 x [4 x double]], [2 x [4 x double]]* %32, i64 0, i64 1
%84 = getelementptr inbounds [4 x double], [4 x double]* %83, i64 0, i64 0
%85 = load double, double* %84
%86 = fcmp ogt double %82, %85
br i1 %86, label %87, label %91
87: ; preds = %79
%88 = getelementptr inbounds [2 x [4 x double]], [2 x [4 x double]]* %32, i64 0, i64 0
%89 = getelementptr inbounds [4 x double], [4 x double]* %88, i64 0, i64 0
%90 = load double, double* %89
br label %95
91: ; preds = %79
%92 = getelementptr inbounds [2 x [4 x double]], [2 x [4 x double]]* %32, i64 0, i64 1
%93 = getelementptr inbounds [4 x double], [4 x double]* %92, i64 0, i64 0
%94 = load double, double* %93
br label %95
95: ; preds = %91, %87
%96 = phi double [ %90, %87 ], [ %94, %91 ]
store double %96, double* %9
%97 = getelementptr inbounds [2 x [4 x double]], [2 x [4 x double]]* %32, i64 0, i64 0
%98 = getelementptr inbounds [4 x double], [4 x double]* %97, i64 0, i64 3
%99 = load double, double* %98
%100 = getelementptr inbounds [2 x [4 x double]], [2 x [4 x double]]* %32, i64 0, i64 1
%101 = getelementptr inbounds [4 x double], [4 x double]* %100, i64 0, i64 3
%102 = load double, double* %101
%103 = fcmp olt double %99, %102
br i1 %103, label %104, label %108
104: ; preds = %95
%105 = getelementptr inbounds [2 x [4 x double]], [2 x [4 x double]]* %32, i64 0, i64 0
%106 = getelementptr inbounds [4 x double], [4 x double]* %105, i64 0, i64 3
%107 = load double, double* %106
br label %112
108: ; preds = %95
%109 = getelementptr inbounds [2 x [4 x double]], [2 x [4 x double]]* %32, i64 0, i64 1
%110 = getelementptr inbounds [4 x double], [4 x double]* %109, i64 0, i64 3
%111 = load double, double* %110
br label %112
112: ; preds = %108, %104
%113 = phi double [ %107, %104 ], [ %111, %108 ]
store double %113, double* %10
store i32 0, i32* %18
br label %114
114: ; preds = %958, %112
%115 = load i32, i32* %18
%116 = icmp slt i32 %115, 2
br i1 %116, label %117, label %961
117: ; preds = %114
store i32 0, i32* %17
br label %118
118: ; preds = %171, %117
%119 = load i32, i32* %17
%120 = icmp slt i32 %119, 4
br i1 %120, label %121, label %174
121: ; preds = %118
%122 = load i32, i32* %18
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds [2 x [4 x double]], [2 x [4 x double]]* %32, i64 0, i64 %123
%125 = load i32, i32* %17
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds [4 x double], [4 x double]* %124, i64 0, i64 %126
%128 = load double, double* %127
%129 = load i32, i32* %17
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 %130
store double %128, double* %131
%132 = load i32, i32* %17
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 %133
%135 = load double, double* %134
%136 = load i32, i32* %17
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 %137
%139 = load double, double* %138
%140 = fmul double %135, %139
%141 = load i32, i32* %17
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 %142
store double %140, double* %143
%144 = load i32, i32* %17
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 %145
%147 = load double, double* %146
%148 = load i32, i32* %17
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 %149
%151 = load double, double* %150
%152 = fmul double %147, %151
%153 = load i32, i32* %17
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 %154
%156 = load double, double* %155
%157 = fmul double %152, %156
%158 = load i32, i32* %17
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 %159
store double %157, double* %160
%161 = load i32, i32* %18
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds [2 x [4 x double]], [2 x [4 x double]]* %33, i64 0, i64 %162
%164 = load i32, i32* %17
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds [4 x double], [4 x double]* %163, i64 0, i64 %165
%167 = load double, double* %166
%168 = load i32, i32* %17
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 %169
store double %167, double* %170
br label %171
171: ; preds = %121
%172 = load i32, i32* %17
%173 = add nsw i32 %172, 1
store i32 %173, i32* %17
br label %118
174: ; preds = %118
%175 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 1
%176 = load double, double* %175
%177 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 2
%178 = load double, double* %177
%179 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 3
%180 = load double, double* %179
%181 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 3
%182 = load double, double* %181
%183 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 2
%184 = load double, double* %183
%185 = fmul double %182, %184
%186 = fneg double %185
%187 = call double @llvm.fmuladd.f64(double %178, double %180, double %186)
%188 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 2
%189 = load double, double* %188
%190 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 1
%191 = load double, double* %190
%192 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 3
%193 = load double, double* %192
%194 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 3
%195 = load double, double* %194
%196 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 1
%197 = load double, double* %196
%198 = fmul double %195, %197
%199 = fneg double %198
%200 = call double @llvm.fmuladd.f64(double %191, double %193, double %199)
%201 = fmul double %189, %200
%202 = fneg double %201
%203 = call double @llvm.fmuladd.f64(double %176, double %187, double %202)
%204 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 3
%205 = load double, double* %204
%206 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 1
%207 = load double, double* %206
%208 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 2
%209 = load double, double* %208
%210 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 2
%211 = load double, double* %210
%212 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 1
%213 = load double, double* %212
%214 = fmul double %211, %213
%215 = fneg double %214
%216 = call double @llvm.fmuladd.f64(double %207, double %209, double %215)
%217 = call double @llvm.fmuladd.f64(double %205, double %216, double %203)
store double %217, double* %19
%218 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 0
%219 = load double, double* %218
%220 = fneg double %219
%221 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 2
%222 = load double, double* %221
%223 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 3
%224 = load double, double* %223
%225 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 3
%226 = load double, double* %225
%227 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 2
%228 = load double, double* %227
%229 = fmul double %226, %228
%230 = fneg double %229
%231 = call double @llvm.fmuladd.f64(double %222, double %224, double %230)
%232 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 2
%233 = load double, double* %232
%234 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 0
%235 = load double, double* %234
%236 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 3
%237 = load double, double* %236
%238 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 3
%239 = load double, double* %238
%240 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 0
%241 = load double, double* %240
%242 = fmul double %239, %241
%243 = fneg double %242
%244 = call double @llvm.fmuladd.f64(double %235, double %237, double %243)
%245 = fmul double %233, %244
%246 = call double @llvm.fmuladd.f64(double %220, double %231, double %245)
%247 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 3
%248 = load double, double* %247
%249 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 0
%250 = load double, double* %249
%251 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 2
%252 = load double, double* %251
%253 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 2
%254 = load double, double* %253
%255 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 0
%256 = load double, double* %255
%257 = fmul double %254, %256
%258 = fneg double %257
%259 = call double @llvm.fmuladd.f64(double %250, double %252, double %258)
%260 = fneg double %248
%261 = call double @llvm.fmuladd.f64(double %260, double %259, double %246)
store double %261, double* %20
%262 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 0
%263 = load double, double* %262
%264 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 1
%265 = load double, double* %264
%266 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 3
%267 = load double, double* %266
%268 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 3
%269 = load double, double* %268
%270 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 1
%271 = load double, double* %270
%272 = fmul double %269, %271
%273 = fneg double %272
%274 = call double @llvm.fmuladd.f64(double %265, double %267, double %273)
%275 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 1
%276 = load double, double* %275
%277 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 0
%278 = load double, double* %277
%279 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 3
%280 = load double, double* %279
%281 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 3
%282 = load double, double* %281
%283 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 0
%284 = load double, double* %283
%285 = fmul double %282, %284
%286 = fneg double %285
%287 = call double @llvm.fmuladd.f64(double %278, double %280, double %286)
%288 = fmul double %276, %287
%289 = fneg double %288
%290 = call double @llvm.fmuladd.f64(double %263, double %274, double %289)
%291 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 3
%292 = load double, double* %291
%293 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 0
%294 = load double, double* %293
%295 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 1
%296 = load double, double* %295
%297 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 1
%298 = load double, double* %297
%299 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 0
%300 = load double, double* %299
%301 = fmul double %298, %300
%302 = fneg double %301
%303 = call double @llvm.fmuladd.f64(double %294, double %296, double %302)
%304 = call double @llvm.fmuladd.f64(double %292, double %303, double %290)
store double %304, double* %21
%305 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 0
%306 = load double, double* %305
%307 = fneg double %306
%308 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 1
%309 = load double, double* %308
%310 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 2
%311 = load double, double* %310
%312 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 2
%313 = load double, double* %312
%314 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 1
%315 = load double, double* %314
%316 = fmul double %313, %315
%317 = fneg double %316
%318 = call double @llvm.fmuladd.f64(double %309, double %311, double %317)
%319 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 1
%320 = load double, double* %319
%321 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 0
%322 = load double, double* %321
%323 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 2
%324 = load double, double* %323
%325 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 2
%326 = load double, double* %325
%327 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 0
%328 = load double, double* %327
%329 = fmul double %326, %328
%330 = fneg double %329
%331 = call double @llvm.fmuladd.f64(double %322, double %324, double %330)
%332 = fmul double %320, %331
%333 = call double @llvm.fmuladd.f64(double %307, double %318, double %332)
%334 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 2
%335 = load double, double* %334
%336 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 0
%337 = load double, double* %336
%338 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 1
%339 = load double, double* %338
%340 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 1
%341 = load double, double* %340
%342 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 0
%343 = load double, double* %342
%344 = fmul double %341, %343
%345 = fneg double %344
%346 = call double @llvm.fmuladd.f64(double %337, double %339, double %345)
%347 = fneg double %335
%348 = call double @llvm.fmuladd.f64(double %347, double %346, double %333)
store double %348, double* %22
%349 = load double, double* %19
%350 = load double, double* %20
%351 = fadd double %349, %350
%352 = load double, double* %21
%353 = fadd double %351, %352
%354 = load double, double* %22
%355 = fadd double %353, %354
store double %355, double* %23
%356 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 0
%357 = load double, double* %356
%358 = load double, double* %19
%359 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 1
%360 = load double, double* %359
%361 = load double, double* %20
%362 = fmul double %360, %361
%363 = call double @llvm.fmuladd.f64(double %357, double %358, double %362)
%364 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 2
%365 = load double, double* %364
%366 = load double, double* %21
%367 = call double @llvm.fmuladd.f64(double %365, double %366, double %363)
%368 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 3
%369 = load double, double* %368
%370 = load double, double* %22
%371 = call double @llvm.fmuladd.f64(double %369, double %370, double %367)
store double %371, double* %24
%372 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 1
%373 = load double, double* %372
%374 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 2
%375 = load double, double* %374
%376 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 3
%377 = load double, double* %376
%378 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 3
%379 = load double, double* %378
%380 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 2
%381 = load double, double* %380
%382 = fmul double %379, %381
%383 = fneg double %382
%384 = call double @llvm.fmuladd.f64(double %375, double %377, double %383)
%385 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 2
%386 = load double, double* %385
%387 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 1
%388 = load double, double* %387
%389 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 3
%390 = load double, double* %389
%391 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 3
%392 = load double, double* %391
%393 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 1
%394 = load double, double* %393
%395 = fmul double %392, %394
%396 = fneg double %395
%397 = call double @llvm.fmuladd.f64(double %388, double %390, double %396)
%398 = fmul double %386, %397
%399 = fneg double %398
%400 = call double @llvm.fmuladd.f64(double %373, double %384, double %399)
%401 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 3
%402 = load double, double* %401
%403 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 1
%404 = load double, double* %403
%405 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 2
%406 = load double, double* %405
%407 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 2
%408 = load double, double* %407
%409 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 1
%410 = load double, double* %409
%411 = fmul double %408, %410
%412 = fneg double %411
%413 = call double @llvm.fmuladd.f64(double %404, double %406, double %412)
%414 = call double @llvm.fmuladd.f64(double %402, double %413, double %400)
%415 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 0
%416 = load double, double* %415
%417 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 2
%418 = load double, double* %417
%419 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 3
%420 = load double, double* %419
%421 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 3
%422 = load double, double* %421
%423 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 2
%424 = load double, double* %423
%425 = fmul double %422, %424
%426 = fneg double %425
%427 = call double @llvm.fmuladd.f64(double %418, double %420, double %426)
%428 = fneg double %416
%429 = call double @llvm.fmuladd.f64(double %428, double %427, double %414)
%430 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 2
%431 = load double, double* %430
%432 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 0
%433 = load double, double* %432
%434 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 3
%435 = load double, double* %434
%436 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 3
%437 = load double, double* %436
%438 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 0
%439 = load double, double* %438
%440 = fmul double %437, %439
%441 = fneg double %440
%442 = call double @llvm.fmuladd.f64(double %433, double %435, double %441)
%443 = call double @llvm.fmuladd.f64(double %431, double %442, double %429)
%444 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 3
%445 = load double, double* %444
%446 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 0
%447 = load double, double* %446
%448 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 2
%449 = load double, double* %448
%450 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 2
%451 = load double, double* %450
%452 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 0
%453 = load double, double* %452
%454 = fmul double %451, %453
%455 = fneg double %454
%456 = call double @llvm.fmuladd.f64(double %447, double %449, double %455)
%457 = fneg double %445
%458 = call double @llvm.fmuladd.f64(double %457, double %456, double %443)
%459 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 0
%460 = load double, double* %459
%461 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 1
%462 = load double, double* %461
%463 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 3
%464 = load double, double* %463
%465 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 3
%466 = load double, double* %465
%467 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 1
%468 = load double, double* %467
%469 = fmul double %466, %468
%470 = fneg double %469
%471 = call double @llvm.fmuladd.f64(double %462, double %464, double %470)
%472 = call double @llvm.fmuladd.f64(double %460, double %471, double %458)
%473 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 1
%474 = load double, double* %473
%475 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 0
%476 = load double, double* %475
%477 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 3
%478 = load double, double* %477
%479 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 3
%480 = load double, double* %479
%481 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 0
%482 = load double, double* %481
%483 = fmul double %480, %482
%484 = fneg double %483
%485 = call double @llvm.fmuladd.f64(double %476, double %478, double %484)
%486 = fneg double %474
%487 = call double @llvm.fmuladd.f64(double %486, double %485, double %472)
%488 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 3
%489 = load double, double* %488
%490 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 0
%491 = load double, double* %490
%492 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 1
%493 = load double, double* %492
%494 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 1
%495 = load double, double* %494
%496 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 0
%497 = load double, double* %496
%498 = fmul double %495, %497
%499 = fneg double %498
%500 = call double @llvm.fmuladd.f64(double %491, double %493, double %499)
%501 = call double @llvm.fmuladd.f64(double %489, double %500, double %487)
%502 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 0
%503 = load double, double* %502
%504 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 1
%505 = load double, double* %504
%506 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 2
%507 = load double, double* %506
%508 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 2
%509 = load double, double* %508
%510 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 1
%511 = load double, double* %510
%512 = fmul double %509, %511
%513 = fneg double %512
%514 = call double @llvm.fmuladd.f64(double %505, double %507, double %513)
%515 = fneg double %503
%516 = call double @llvm.fmuladd.f64(double %515, double %514, double %501)
%517 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 1
%518 = load double, double* %517
%519 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 0
%520 = load double, double* %519
%521 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 2
%522 = load double, double* %521
%523 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 2
%524 = load double, double* %523
%525 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 0
%526 = load double, double* %525
%527 = fmul double %524, %526
%528 = fneg double %527
%529 = call double @llvm.fmuladd.f64(double %520, double %522, double %528)
%530 = call double @llvm.fmuladd.f64(double %518, double %529, double %516)
%531 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 2
%532 = load double, double* %531
%533 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 0
%534 = load double, double* %533
%535 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 1
%536 = load double, double* %535
%537 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 1
%538 = load double, double* %537
%539 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 0
%540 = load double, double* %539
%541 = fmul double %538, %540
%542 = fneg double %541
%543 = call double @llvm.fmuladd.f64(double %534, double %536, double %542)
%544 = fneg double %532
%545 = call double @llvm.fmuladd.f64(double %544, double %543, double %530)
store double %545, double* %25
%546 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 1
%547 = load double, double* %546
%548 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 2
%549 = load double, double* %548
%550 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 3
%551 = load double, double* %550
%552 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 3
%553 = load double, double* %552
%554 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 2
%555 = load double, double* %554
%556 = fmul double %553, %555
%557 = fneg double %556
%558 = call double @llvm.fmuladd.f64(double %549, double %551, double %557)
%559 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 2
%560 = load double, double* %559
%561 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 1
%562 = load double, double* %561
%563 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 3
%564 = load double, double* %563
%565 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 3
%566 = load double, double* %565
%567 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 1
%568 = load double, double* %567
%569 = fmul double %566, %568
%570 = fneg double %569
%571 = call double @llvm.fmuladd.f64(double %562, double %564, double %570)
%572 = fmul double %560, %571
%573 = fneg double %572
%574 = call double @llvm.fmuladd.f64(double %547, double %558, double %573)
%575 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 3
%576 = load double, double* %575
%577 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 1
%578 = load double, double* %577
%579 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 2
%580 = load double, double* %579
%581 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 2
%582 = load double, double* %581
%583 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 1
%584 = load double, double* %583
%585 = fmul double %582, %584
%586 = fneg double %585
%587 = call double @llvm.fmuladd.f64(double %578, double %580, double %586)
%588 = call double @llvm.fmuladd.f64(double %576, double %587, double %574)
%589 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 0
%590 = load double, double* %589
%591 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 2
%592 = load double, double* %591
%593 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 3
%594 = load double, double* %593
%595 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 3
%596 = load double, double* %595
%597 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 2
%598 = load double, double* %597
%599 = fmul double %596, %598
%600 = fneg double %599
%601 = call double @llvm.fmuladd.f64(double %592, double %594, double %600)
%602 = fneg double %590
%603 = call double @llvm.fmuladd.f64(double %602, double %601, double %588)
%604 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 2
%605 = load double, double* %604
%606 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 0
%607 = load double, double* %606
%608 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 3
%609 = load double, double* %608
%610 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 3
%611 = load double, double* %610
%612 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 0
%613 = load double, double* %612
%614 = fmul double %611, %613
%615 = fneg double %614
%616 = call double @llvm.fmuladd.f64(double %607, double %609, double %615)
%617 = call double @llvm.fmuladd.f64(double %605, double %616, double %603)
%618 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 3
%619 = load double, double* %618
%620 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 0
%621 = load double, double* %620
%622 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 2
%623 = load double, double* %622
%624 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 2
%625 = load double, double* %624
%626 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 0
%627 = load double, double* %626
%628 = fmul double %625, %627
%629 = fneg double %628
%630 = call double @llvm.fmuladd.f64(double %621, double %623, double %629)
%631 = fneg double %619
%632 = call double @llvm.fmuladd.f64(double %631, double %630, double %617)
%633 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 0
%634 = load double, double* %633
%635 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 1
%636 = load double, double* %635
%637 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 3
%638 = load double, double* %637
%639 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 3
%640 = load double, double* %639
%641 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 1
%642 = load double, double* %641
%643 = fmul double %640, %642
%644 = fneg double %643
%645 = call double @llvm.fmuladd.f64(double %636, double %638, double %644)
%646 = call double @llvm.fmuladd.f64(double %634, double %645, double %632)
%647 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 1
%648 = load double, double* %647
%649 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 0
%650 = load double, double* %649
%651 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 3
%652 = load double, double* %651
%653 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 3
%654 = load double, double* %653
%655 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 0
%656 = load double, double* %655
%657 = fmul double %654, %656
%658 = fneg double %657
%659 = call double @llvm.fmuladd.f64(double %650, double %652, double %658)
%660 = fneg double %648
%661 = call double @llvm.fmuladd.f64(double %660, double %659, double %646)
%662 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 3
%663 = load double, double* %662
%664 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 0
%665 = load double, double* %664
%666 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 1
%667 = load double, double* %666
%668 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 1
%669 = load double, double* %668
%670 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 0
%671 = load double, double* %670
%672 = fmul double %669, %671
%673 = fneg double %672
%674 = call double @llvm.fmuladd.f64(double %665, double %667, double %673)
%675 = call double @llvm.fmuladd.f64(double %663, double %674, double %661)
%676 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 0
%677 = load double, double* %676
%678 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 1
%679 = load double, double* %678
%680 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 2
%681 = load double, double* %680
%682 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 2
%683 = load double, double* %682
%684 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 1
%685 = load double, double* %684
%686 = fmul double %683, %685
%687 = fneg double %686
%688 = call double @llvm.fmuladd.f64(double %679, double %681, double %687)
%689 = fneg double %677
%690 = call double @llvm.fmuladd.f64(double %689, double %688, double %675)
%691 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 1
%692 = load double, double* %691
%693 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 0
%694 = load double, double* %693
%695 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 2
%696 = load double, double* %695
%697 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 2
%698 = load double, double* %697
%699 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 0
%700 = load double, double* %699
%701 = fmul double %698, %700
%702 = fneg double %701
%703 = call double @llvm.fmuladd.f64(double %694, double %696, double %702)
%704 = call double @llvm.fmuladd.f64(double %692, double %703, double %690)
%705 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 2
%706 = load double, double* %705
%707 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 0
%708 = load double, double* %707
%709 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 1
%710 = load double, double* %709
%711 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 1
%712 = load double, double* %711
%713 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 0
%714 = load double, double* %713
%715 = fmul double %712, %714
%716 = fneg double %715
%717 = call double @llvm.fmuladd.f64(double %708, double %710, double %716)
%718 = fneg double %706
%719 = call double @llvm.fmuladd.f64(double %718, double %717, double %704)
store double %719, double* %26
%720 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 1
%721 = load double, double* %720
%722 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 2
%723 = load double, double* %722
%724 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 3
%725 = load double, double* %724
%726 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 3
%727 = load double, double* %726
%728 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 2
%729 = load double, double* %728
%730 = fmul double %727, %729
%731 = fneg double %730
%732 = call double @llvm.fmuladd.f64(double %723, double %725, double %731)
%733 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 2
%734 = load double, double* %733
%735 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 1
%736 = load double, double* %735
%737 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 3
%738 = load double, double* %737
%739 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 3
%740 = load double, double* %739
%741 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 1
%742 = load double, double* %741
%743 = fmul double %740, %742
%744 = fneg double %743
%745 = call double @llvm.fmuladd.f64(double %736, double %738, double %744)
%746 = fmul double %734, %745
%747 = fneg double %746
%748 = call double @llvm.fmuladd.f64(double %721, double %732, double %747)
%749 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 3
%750 = load double, double* %749
%751 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 1
%752 = load double, double* %751
%753 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 2
%754 = load double, double* %753
%755 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 2
%756 = load double, double* %755
%757 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 1
%758 = load double, double* %757
%759 = fmul double %756, %758
%760 = fneg double %759
%761 = call double @llvm.fmuladd.f64(double %752, double %754, double %760)
%762 = call double @llvm.fmuladd.f64(double %750, double %761, double %748)
%763 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 0
%764 = load double, double* %763
%765 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 2
%766 = load double, double* %765
%767 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 3
%768 = load double, double* %767
%769 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 3
%770 = load double, double* %769
%771 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 2
%772 = load double, double* %771
%773 = fmul double %770, %772
%774 = fneg double %773
%775 = call double @llvm.fmuladd.f64(double %766, double %768, double %774)
%776 = fneg double %764
%777 = call double @llvm.fmuladd.f64(double %776, double %775, double %762)
%778 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 2
%779 = load double, double* %778
%780 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 0
%781 = load double, double* %780
%782 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 3
%783 = load double, double* %782
%784 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 3
%785 = load double, double* %784
%786 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 0
%787 = load double, double* %786
%788 = fmul double %785, %787
%789 = fneg double %788
%790 = call double @llvm.fmuladd.f64(double %781, double %783, double %789)
%791 = call double @llvm.fmuladd.f64(double %779, double %790, double %777)
%792 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 3
%793 = load double, double* %792
%794 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 0
%795 = load double, double* %794
%796 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 2
%797 = load double, double* %796
%798 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 2
%799 = load double, double* %798
%800 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 0
%801 = load double, double* %800
%802 = fmul double %799, %801
%803 = fneg double %802
%804 = call double @llvm.fmuladd.f64(double %795, double %797, double %803)
%805 = fneg double %793
%806 = call double @llvm.fmuladd.f64(double %805, double %804, double %791)
%807 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 0
%808 = load double, double* %807
%809 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 1
%810 = load double, double* %809
%811 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 3
%812 = load double, double* %811
%813 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 3
%814 = load double, double* %813
%815 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 1
%816 = load double, double* %815
%817 = fmul double %814, %816
%818 = fneg double %817
%819 = call double @llvm.fmuladd.f64(double %810, double %812, double %818)
%820 = call double @llvm.fmuladd.f64(double %808, double %819, double %806)
%821 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 1
%822 = load double, double* %821
%823 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 0
%824 = load double, double* %823
%825 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 3
%826 = load double, double* %825
%827 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 3
%828 = load double, double* %827
%829 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 0
%830 = load double, double* %829
%831 = fmul double %828, %830
%832 = fneg double %831
%833 = call double @llvm.fmuladd.f64(double %824, double %826, double %832)
%834 = fneg double %822
%835 = call double @llvm.fmuladd.f64(double %834, double %833, double %820)
%836 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 3
%837 = load double, double* %836
%838 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 0
%839 = load double, double* %838
%840 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 1
%841 = load double, double* %840
%842 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 1
%843 = load double, double* %842
%844 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 0
%845 = load double, double* %844
%846 = fmul double %843, %845
%847 = fneg double %846
%848 = call double @llvm.fmuladd.f64(double %839, double %841, double %847)
%849 = call double @llvm.fmuladd.f64(double %837, double %848, double %835)
%850 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 0
%851 = load double, double* %850
%852 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 1
%853 = load double, double* %852
%854 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 2
%855 = load double, double* %854
%856 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 2
%857 = load double, double* %856
%858 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 1
%859 = load double, double* %858
%860 = fmul double %857, %859
%861 = fneg double %860
%862 = call double @llvm.fmuladd.f64(double %853, double %855, double %861)
%863 = fneg double %851
%864 = call double @llvm.fmuladd.f64(double %863, double %862, double %849)
%865 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 1
%866 = load double, double* %865
%867 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 0
%868 = load double, double* %867
%869 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 2
%870 = load double, double* %869
%871 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 2
%872 = load double, double* %871
%873 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 0
%874 = load double, double* %873
%875 = fmul double %872, %874
%876 = fneg double %875
%877 = call double @llvm.fmuladd.f64(double %868, double %870, double %876)
%878 = call double @llvm.fmuladd.f64(double %866, double %877, double %864)
%879 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 2
%880 = load double, double* %879
%881 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 0
%882 = load double, double* %881
%883 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 1
%884 = load double, double* %883
%885 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 1
%886 = load double, double* %885
%887 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 0, i64 0
%888 = load double, double* %887
%889 = fmul double %886, %888
%890 = fneg double %889
%891 = call double @llvm.fmuladd.f64(double %882, double %884, double %890)
%892 = fneg double %880
%893 = call double @llvm.fmuladd.f64(double %892, double %891, double %878)
store double %893, double* %27
%894 = load double, double* %24
%895 = load double, double* %23
%896 = fdiv double %894, %895
store double %896, double* %28
%897 = load double, double* %25
%898 = load double, double* %23
%899 = fdiv double %897, %898
store double %899, double* %29
%900 = load double, double* %26
%901 = load double, double* %23
%902 = fdiv double %900, %901
store double %902, double* %30
%903 = load double, double* %27
%904 = load double, double* %23
%905 = fdiv double %903, %904
store double %905, double* %31
%906 = load double, double* %28
%907 = load double, double* %10
%908 = load double, double* %9
%909 = fsub double %907, %908
%910 = load double, double* %29
%911 = load double, double* %10
%912 = load double, double* %10
%913 = load double, double* %9
%914 = load double, double* %9
%915 = fmul double %913, %914
%916 = fneg double %915
%917 = call double @llvm.fmuladd.f64(double %911, double %912, double %916)
%918 = fmul double %910, %917
%919 = fdiv double %918, 2.000000e+00
%920 = call double @llvm.fmuladd.f64(double %906, double %909, double %919)
%921 = load double, double* %30
%922 = load double, double* %10
%923 = load double, double* %10
%924 = fmul double %922, %923
%925 = load double, double* %10
%926 = load double, double* %9
%927 = load double, double* %9
%928 = fmul double %926, %927
%929 = load double, double* %9
%930 = fmul double %928, %929
%931 = fneg double %930
%932 = call double @llvm.fmuladd.f64(double %924, double %925, double %931)
%933 = fmul double %921, %932
%934 = fdiv double %933, 3.000000e+00
%935 = fadd double %920, %934
%936 = load double, double* %31
%937 = load double, double* %10
%938 = load double, double* %10
%939 = fmul double %937, %938
%940 = load double, double* %10
%941 = fmul double %939, %940
%942 = load double, double* %10
%943 = load double, double* %9
%944 = load double, double* %9
%945 = fmul double %943, %944
%946 = load double, double* %9
%947 = fmul double %945, %946
%948 = load double, double* %9
%949 = fmul double %947, %948
%950 = fneg double %949
%951 = call double @llvm.fmuladd.f64(double %941, double %942, double %950)
%952 = fmul double %936, %951
%953 = fdiv double %952, 4.000000e+00
%954 = fadd double %935, %953
%955 = load i32, i32* %18
%956 = sext i32 %955 to i64
%957 = getelementptr inbounds [2 x double], [2 x double]* %16, i64 0, i64 %956
store double %954, double* %957
br label %958
958: ; preds = %174
%959 = load i32, i32* %18
%960 = add nsw i32 %959, 1
store i32 %960, i32* %18
br label %114
961: ; preds = %114
%962 = getelementptr inbounds [2 x double], [2 x double]* %16, i64 0, i64 1
%963 = load double, double* %962
%964 = getelementptr inbounds [2 x double], [2 x double]* %16, i64 0, i64 0
%965 = load double, double* %964
%966 = fsub double %963, %965
%967 = load double, double* %10
%968 = load double, double* %9
%969 = fsub double %967, %968
%970 = fdiv double %966, %969
store double %970, double* %11
%971 = load double, double* %11
%972 = call double @exp(double %971)
%973 = fsub double %972, 1.000000e+00
%974 = fmul double %973, 1.000000e+02
store double %974, double* %11
%975 = load double, double* %11
ret double %975
}

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