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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ free(double *);
scalar_t__ log(double);
double *malloc(int);
void fb_once(int T, int K, double *p_x_z, double *A, double *pi, double *g,
             double *xi, double *ln_z) {
  double *a, *b, *c;
  a = malloc(T * K * sizeof(double));
  b = malloc(T * K * sizeof(double));
  c = malloc(T * sizeof(double));
  int i;
  for (i = 0; i < T * K; i++) {
    a[i] = 0;
    b[i] = 0;
  }
  for (i = 0; i < T; i++) {
    c[i] = 0;
  }
  int k;
  for (k = 0; k < K; k++) {
    a[0 * K + k] = pi[k] * p_x_z[0 * K + k];
    c[0] += a[0 * K + k];
  }
  for (k = 0; k < K; k++) {
    a[0 * K + k] /= c[0];
  }
  int t = 0;
  int l;
  for (t = 1; t < T; t++) {
    for (k = 0; k < K; k++) {
      for (l = 0; l < K; l++) {
        a[t * K + k] += p_x_z[t * K + k] * A[l * K + k] * a[(t - 1) * K + l];
      }
      c[t] += a[t * K + k];
    }
    for (k = 0; k < K; k++) {
      a[t * K + k] /= c[t];
    }
  }
  for (k = 0; k < K; k++) {
    b[(T - 1) * K + k] = 1;
  }
  for (t = T - 2; t >= 0; t--) {
    for (k = 0; k < K; k++) {
      for (l = 0; l < K; l++) {
        b[t * K + k] +=
            p_x_z[(t + 1) * K + l] * A[k * K + l] * b[(t + 1) * K + l];
      }
      b[t * K + k] /= c[t + 1];
    }
  }
  for (i = 0; i < T * K; i++) {
    g[i] = a[i] * b[i];
  }
  for (t = 0; t < T - 1; t++) {
    for (k = 0; k < K; k++) {
      for (l = 0; l < K; l++) {
        xi[t * K * K + k * K + l] =
            (a[t * K + k] * A[k * K + l] * p_x_z[(t + 1) * K + l] *
             b[(t + 1) * K + l]) /
            c[t + 1];
      }
    }
  }
  for (t = 0; t < T; t++) {
    *ln_z += log(c[t]);
  }
  free(a);
  free(b);
  free(c);
  return;
}


x86 assembly (clang, -O0):
<fb_once>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x4(%rbp),%eax
imul   -0x8(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x4(%rbp),%eax
imul   -0x8(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x38(%rbp)
movslq -0x4(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x8(%rbp),%ecx
cmp    %ecx,%eax
jge    11e0 <fb_once+0xb0>
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11a0 <fb_once+0x70>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1211 <fb_once+0xe1>
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11e7 <fb_once+0xb7>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1284 <fb_once+0x154>
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
imul   $0x0,-0x8(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
imul   $0x0,-0x8(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
imul   $0x0,-0x8(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1218 <fb_once+0xe8>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12c9 <fb_once+0x199>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x30(%rbp),%rax
imul   $0x0,-0x8(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    128b <fb_once+0x15b>
movl   $0x0,-0x4c(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1415 <fb_once+0x2e5>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13b5 <fb_once+0x285>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    137f <fb_once+0x24f>
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x8(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    12fd <fb_once+0x1cd>
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    12ea <fb_once+0x1ba>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1402 <fb_once+0x2d2>
mov    -0x40(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    13bc <fb_once+0x28c>
jmp    1407 <fb_once+0x2d7>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12d7 <fb_once+0x1a7>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1457 <fb_once+0x327>
mov    -0x38(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x8(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xbbc(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    141c <fb_once+0x2ec>
mov    -0x4(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jl     155b <fb_once+0x42b>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1548 <fb_once+0x418>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1509 <fb_once+0x3d9>
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x8(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x8(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1484 <fb_once+0x354>
mov    -0x40(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1471 <fb_once+0x341>
jmp    154d <fb_once+0x41d>
mov    -0x4c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x4c(%rbp)
jmp    1460 <fb_once+0x330>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x8(%rbp),%ecx
cmp    %ecx,%eax
jge    15a9 <fb_once+0x479>
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1562 <fb_once+0x432>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    16ae <fb_once+0x57e>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    169b <fb_once+0x56b>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1688 <fb_once+0x558>
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x8(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x8(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    -0x48(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    15db <fb_once+0x4ab>
jmp    168d <fb_once+0x55d>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    15c8 <fb_once+0x498>
jmp    16a0 <fb_once+0x570>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    15b0 <fb_once+0x480>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    16f2 <fb_once+0x5c2>
mov    -0x40(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1050 <log@plt>
cvtsi2sd %rax,%xmm0
mov    0x18(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    16b5 <fb_once+0x585>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fb_once>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r9,0x70(%rsp)
mov    %r8,0x8(%rsp)
mov    %rcx,0x30(%rsp)
mov    %rdx,0x28(%rsp)
mov    %edi,%r12d
mov    0xd8(%rsp),%r15
mov    0xd0(%rsp),%rax
mov    %rax,0x80(%rsp)
mov    %esi,0x4(%rsp)
mov    %esi,%ebp
imul   %edi,%ebp
lea    0x0(,%rbp,8),%ebx
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r13
mov    %r12,0x10(%rsp)
lea    0x0(,%r12,8),%edi
call   1050 <malloc@plt>
mov    %rax,%r12
mov    %ebp,%ebx
mov    %rbp,0x68(%rsp)
test   %ebp,%ebp
jle    11e6 <fb_once+0xa6>
lea    0x0(,%rbx,8),%rbp
mov    %r14,%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1040 <memset@plt>
mov    %r13,%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1040 <memset@plt>
mov    %rbx,0x38(%rsp)
mov    %r13,0x48(%rsp)
mov    %r15,0x90(%rsp)
mov    0x10(%rsp),%rax
mov    %eax,%ebx
test   %eax,%eax
jle    1215 <fb_once+0xd5>
lea    0x0(,%rbx,8),%rdx
mov    %r12,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
mov    %rbx,0x88(%rsp)
mov    0x4(%rsp),%ebx
mov    %ebx,%r15d
test   %ebx,%ebx
mov    0x28(%rsp),%r13
jle    1369 <fb_once+0x229>
movsd  (%r12),%xmm0
cmp    $0x1,%ebx
jne    1248 <fb_once+0x108>
xor    %ecx,%ecx
mov    %r13,%rax
mov    0x8(%rsp),%rsi
jmp    1294 <fb_once+0x154>
mov    %r15d,%edx
and    $0xfffffffe,%edx
xor    %ecx,%ecx
mov    %r13,%rax
mov    0x8(%rsp),%rsi
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rcx,8),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  %xmm1,(%r14,%rcx,8)
addsd  %xmm0,%xmm1
movsd  0x8(%rsi,%rcx,8),%xmm0
mulsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r14,%rcx,8)
addsd  %xmm1,%xmm0
add    $0x2,%rcx
cmp    %rcx,%rdx
jne    1260 <fb_once+0x120>
test   $0x1,%r15b
je     12ae <fb_once+0x16e>
movsd  (%rsi,%rcx,8),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  %xmm1,(%r14,%rcx,8)
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r12)
test   %ebx,%ebx
jle    1369 <fb_once+0x229>
movsd  (%r12),%xmm0
cmp    $0x1,%ebx
jne    12ce <fb_once+0x18e>
xor    %ecx,%ecx
jmp    1350 <fb_once+0x210>
mov    %r15d,%ecx
and    $0xfffffffe,%ecx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%rcx),%rax
mov    %rax,%rdx
shr    %rdx
add    $0x1,%rdx
test   %rax,%rax
je     1ca6 <fb_once+0xb66>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
movupd (%r14,%rsi,8),%xmm2
movupd 0x10(%r14,%rsi,8),%xmm3
divpd  %xmm1,%xmm2
movupd %xmm2,(%r14,%rsi,8)
divpd  %xmm1,%xmm3
movupd %xmm3,0x10(%r14,%rsi,8)
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1300 <fb_once+0x1c0>
test   $0x1,%dl
je     1341 <fb_once+0x201>
movupd (%r14,%rsi,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%r14,%rsi,8)
cmp    %r15,%rcx
je     1369 <fb_once+0x229>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r14,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r15
jne    1350 <fb_once+0x210>
cmpl   $0x2,0x10(%rsp)
mov    %r12,0x50(%rsp)
jl     15ee <fb_once+0x4ae>
movslq %ebx,%rdx
mov    %r15d,%eax
and    $0xfffffffe,%eax
lea    -0x2(%rax),%rcx
mov    %rcx,0x78(%rsp)
mov    %rcx,%rsi
shr    %rsi
add    $0x1,%rsi
mov    %rsi,%rcx
mov    %rsi,0x60(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x58(%rsp)
lea    0x0(,%rdx,8),%rsi
mov    %rdx,%rcx
shl    $0x4,%rcx
lea    0x8(%r14),%rdi
lea    (%r14,%rdx,8),%r11
add    $0x10,%r11
mov    %rdx,0x8(%rsp)
lea    (%r14,%rdx,8),%r9
mov    $0x1,%r8d
jmp    13fb <fb_once+0x2bb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r8
add    %rsi,%rdi
add    %rsi,%r11
add    %rsi,%r9
cmp    0x88(%rsp),%r8
je     15ee <fb_once+0x4ae>
test   %ebx,%ebx
jle    13e0 <fb_once+0x2a0>
mov    %r11,0x40(%rsp)
mov    %r8,%r10
mov    0x8(%rsp),%rdx
imul   %rdx,%r10
lea    -0x1(%r8),%rbp
imul   %rdx,%rbp
mov    %rbp,0x20(%rsp)
mov    %r8,0x18(%rsp)
movsd  (%r12,%r8,8),%xmm0
mov    0x30(%rsp),%rbp
xor    %r11d,%r11d
mov    %r13,%rdx
jmp    1459 <fb_once+0x319>
cs nopw 0x0(%rax,%rax,1)
nop
addsd  %xmm1,%xmm0
add    $0x1,%r11
add    $0x8,%rbp
cmp    %r15,%r11
mov    0x4(%rsp),%ebx
je     1520 <fb_once+0x3e0>
lea    (%r11,%r10,1),%r12
movsd  (%rdx,%r12,8),%xmm2
movsd  (%r14,%r12,8),%xmm1
cmp    $0x1,%ebx
jne    1480 <fb_once+0x340>
xor    %r8d,%r8d
jmp    14d2 <fb_once+0x392>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rbp,%r13
xor    %r8d,%r8d
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%r13),%xmm3
mulsd  %xmm2,%xmm3
mulsd  -0x8(%rdi,%r8,8),%xmm3
addsd  %xmm1,%xmm3
movsd  %xmm3,(%r14,%r12,8)
movsd  0x0(%r13,%rsi,1),%xmm1
mulsd  %xmm2,%xmm1
mulsd  (%rdi,%r8,8),%xmm1
addsd  %xmm3,%xmm1
movsd  %xmm1,(%r14,%r12,8)
add    $0x2,%r8
add    %rcx,%r13
cmp    %r8,%rax
jne    1490 <fb_once+0x350>
test   $0x1,%r15b
je     1440 <fb_once+0x300>
mov    %r8,%rdx
imul   0x8(%rsp),%rdx
add    %r11,%rdx
mov    0x30(%rsp),%rbx
mulsd  (%rbx,%rdx,8),%xmm2
mov    0x28(%rsp),%rdx
add    0x20(%rsp),%r8
mulsd  (%r14,%r8,8),%xmm2
addsd  %xmm2,%xmm1
movsd  %xmm1,(%r14,%r12,8)
jmp    1440 <fb_once+0x300>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rdx,%r13
mov    0x50(%rsp),%r12
mov    0x18(%rsp),%r8
movsd  %xmm0,(%r12,%r8,8)
test   %ebx,%ebx
mov    0x40(%rsp),%r11
jle    13e0 <fb_once+0x2a0>
movsd  (%r12,%r8,8),%xmm0
cmp    $0x1,%ebx
jne    1552 <fb_once+0x412>
xor    %edx,%edx
jmp    15d0 <fb_once+0x490>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x78(%rsp)
je     159e <fb_once+0x45e>
mov    0x58(%rsp),%r8
xor    %ebp,%ebp
nopl   0x0(%rax)
movupd -0x10(%r11,%rbp,8),%xmm2
movupd (%r11,%rbp,8),%xmm3
divpd  %xmm1,%xmm2
movupd %xmm2,-0x10(%r11,%rbp,8)
divpd  %xmm1,%xmm3
movupd %xmm3,(%r11,%rbp,8)
add    $0x4,%rbp
add    $0xfffffffffffffffe,%r8
jne    1570 <fb_once+0x430>
jmp    15a0 <fb_once+0x460>
xor    %ebp,%ebp
testb  $0x1,0x60(%rsp)
mov    0x4(%rsp),%ebx
mov    0x18(%rsp),%r8
je     15c3 <fb_once+0x483>
add    %r10,%rbp
movupd (%r14,%rbp,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%r14,%rbp,8)
mov    %rax,%rdx
cmp    %r15,%rax
je     13e0 <fb_once+0x2a0>
nop
movsd  (%r9,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r9,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r15
jne    15d0 <fb_once+0x490>
jmp    13e0 <fb_once+0x2a0>
test   %ebx,%ebx
mov    0x48(%rsp),%rbx
jle    16fd <fb_once+0x5bd>
mov    0x10(%rsp),%rax
add    $0xffffffff,%eax
mov    0x4(%rsp),%ecx
imul   %ecx,%eax
movslq %eax,%r8
cmp    $0x4,%ecx
jae    1619 <fb_once+0x4d9>
xor    %ecx,%ecx
jmp    16d9 <fb_once+0x599>
mov    %r15d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rax
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0xc,%rax
jae    163d <fb_once+0x4fd>
xor    %ebp,%ebp
jmp    1699 <fb_once+0x559>
and    $0xfffffffffffffffc,%rdi
lea    (%rbx,%r8,8),%rdx
add    $0x70,%rdx
xor    %ebp,%ebp
movapd 0x9ad(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd %xmm0,-0x70(%rdx,%rbp,8)
movupd %xmm0,-0x60(%rdx,%rbp,8)
movupd %xmm0,-0x50(%rdx,%rbp,8)
movupd %xmm0,-0x40(%rdx,%rbp,8)
movupd %xmm0,-0x30(%rdx,%rbp,8)
movupd %xmm0,-0x20(%rdx,%rbp,8)
movupd %xmm0,-0x10(%rdx,%rbp,8)
movupd %xmm0,(%rdx,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1660 <fb_once+0x520>
test   %rsi,%rsi
je     16d4 <fb_once+0x594>
add    %r8,%rbp
lea    (%rbx,%rbp,8),%rax
add    $0x10,%rax
shl    $0x5,%rsi
xor    %edx,%edx
movapd 0x949(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movupd %xmm0,-0x10(%rax,%rdx,1)
movupd %xmm0,(%rax,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    16c0 <fb_once+0x580>
cmp    %r15,%rcx
je     16fd <fb_once+0x5bd>
lea    (%rbx,%r8,8),%rax
movabs $0x3ff0000000000000,%rdx
nopw   0x0(%rax,%rax,1)
mov    %rdx,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r15
jne    16f0 <fb_once+0x5b0>
cmpl   $0x2,0x10(%rsp)
mov    0x4(%rsp),%r8d
jl     189f <fb_once+0x75f>
mov    0x10(%rsp),%rax
add    $0xfffffffe,%eax
movslq %r8d,%rcx
mov    %r15d,%esi
and    $0xfffffffe,%esi
mov    %rax,0x20(%rsp)
add    $0x1,%rax
imul   %rcx,%rax
lea    (%rbx,%rax,8),%rdi
add    $0x8,%rdi
mov    %rcx,0x8(%rsp)
lea    0x0(,%rcx,8),%r12
mov    %r12,%rcx
neg    %rcx
mov    %rcx,0x18(%rsp)
mov    0x28(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
add    $0x8,%rcx
mov    0x30(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x40(%rsp)
jmp    1792 <fb_once+0x652>
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rdx
lea    -0x1(%rdx),%rax
mov    0x18(%rsp),%rbp
add    %rbp,%rdi
add    %rbp,%rcx
test   %rdx,%rdx
mov    %rax,0x20(%rsp)
jle    189f <fb_once+0x75f>
test   %r8d,%r8d
jle    1770 <fb_once+0x630>
mov    0x20(%rsp),%rdx
lea    0x1(%rdx),%r13
mov    0x8(%rsp),%rax
imul   %rax,%r13
mov    %rdx,%rbp
imul   %rax,%rbp
mov    0x50(%rsp),%rax
movsd  0x8(%rax,%rdx,8),%xmm0
mov    0x40(%rsp),%r11
xor    %r9d,%r9d
jmp    17ea <fb_once+0x6aa>
cs nopw 0x0(%rax,%rax,1)
nop
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
add    $0x1,%r9
add    %r12,%r11
cmp    %r15,%r9
mov    0x4(%rsp),%r8d
je     1770 <fb_once+0x630>
lea    (%r9,%rbp,1),%rdx
movsd  (%rbx,%rdx,8),%xmm1
cmp    $0x1,%r8d
jne    1800 <fb_once+0x6c0>
xor    %r8d,%r8d
jmp    1852 <fb_once+0x712>
xchg   %ax,%ax
xor    %r8d,%r8d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%rcx,%r8,8),%xmm2
mulsd  -0x8(%r11,%r8,8),%xmm2
mulsd  -0x8(%rdi,%r8,8),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rbx,%rdx,8)
movsd  (%rcx,%r8,8),%xmm1
mulsd  (%r11,%r8,8),%xmm1
mulsd  (%rdi,%r8,8),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
add    $0x2,%r8
cmp    %r8,%rsi
jne    1810 <fb_once+0x6d0>
test   $0x1,%r15b
je     17d0 <fb_once+0x690>
mov    %r9,%rax
imul   0x8(%rsp),%rax
lea    (%r8,%r13,1),%r10
mov    0x28(%rsp),%rbx
movsd  (%rbx,%r10,8),%xmm2
add    %r8,%rax
mov    0x30(%rsp),%rbx
mulsd  (%rbx,%rax,8),%xmm2
mov    0x48(%rsp),%rax
mulsd  (%rax,%r10,8),%xmm2
mov    0x48(%rsp),%rbx
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
jmp    17d0 <fb_once+0x690>
mov    0x68(%rsp),%rcx
test   %ecx,%ecx
mov    0x50(%rsp),%r12
mov    0x70(%rsp),%rbp
mov    0x38(%rsp),%rax
jle    19ba <fb_once+0x87a>
cmp    $0x4,%ecx
jae    18c7 <fb_once+0x787>
xor    %ecx,%ecx
jmp    19a0 <fb_once+0x860>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rax
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rax,%rax
je     1c91 <fb_once+0xb51>
movabs $0x7ffffffffffffffc,%rdi
ff ff 7f
or     $0x2,%rdi
and    %rdx,%rdi
xor    %esi,%esi
mov    0x38(%rsp),%rax
nopl   0x0(%rax)
movupd (%r14,%rsi,8),%xmm0
movupd 0x10(%r14,%rsi,8),%xmm1
movupd (%rbx,%rsi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rsi,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x0(%rbp,%rsi,8)
movupd %xmm0,0x10(%rbp,%rsi,8)
movupd 0x20(%r14,%rsi,8),%xmm0
movupd 0x30(%r14,%rsi,8),%xmm1
movupd 0x20(%rbx,%rsi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rbx,%rsi,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%rbp,%rsi,8)
movupd %xmm0,0x30(%rbp,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1900 <fb_once+0x7c0>
test   $0x1,%dl
je     1995 <fb_once+0x855>
movupd (%r14,%rsi,8),%xmm0
movupd 0x10(%r14,%rsi,8),%xmm1
movupd (%rbx,%rsi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rsi,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x0(%rbp,%rsi,8)
movupd %xmm0,0x10(%rbp,%rsi,8)
cmp    %rax,%rcx
je     19ba <fb_once+0x87a>
nopw   0x0(%rax,%rax,1)
movsd  (%r14,%rcx,8),%xmm0
mulsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    19a0 <fb_once+0x860>
cmpl   $0x2,0x10(%rsp)
jl     1c18 <fb_once+0xad8>
mov    0x10(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0x70(%rsp)
movslq %r8d,%rcx
lea    -0x1(%r15),%rsi
mov    0x80(%rsp),%rax
lea    (%rax,%r15,8),%rax
mov    %rax,0x78(%rsp)
mov    0x28(%rsp),%rax
lea    (%rax,%r15,8),%rax
mov    %rax,0x68(%rsp)
mov    %r15d,%ebp
and    $0xfffffffe,%ebp
mov    %rcx,0x18(%rsp)
lea    0x0(,%rcx,8),%rdi
xor    %ecx,%ecx
mov    %rsi,0x60(%rsp)
mov    %rdi,0x58(%rsp)
jmp    1a32 <fb_once+0x8f2>
nopl   0x0(%rax)
add    $0x1,%rcx
mov    %rcx,%rax
cmp    0x70(%rsp),%rax
je     1c18 <fb_once+0xad8>
test   %r8d,%r8d
jle    1a20 <fb_once+0x8e0>
mov    %rcx,%rdx
mov    0x18(%rsp),%r9
imul   %r9,%rdx
lea    0x1(%rcx),%rax
mov    %rax,0x38(%rsp)
imul   %r9,%rax
movsd  0x8(%r12,%rcx,8),%xmm0
mov    %rdx,%rcx
mov    %rdx,0x8(%rsp)
mov    %edx,%r9d
imul   %r8d,%r9d
mov    0x28(%rsp),%rcx
lea    (%rcx,%rax,8),%rdx
mov    0x68(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    %rcx,0x40(%rsp)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    (%rbx,%rax,8),%r10
mov    %r9,0x20(%rsp)
mov    0x30(%rsp),%r13
xor    %r12d,%r12d
mov    0x80(%rsp),%rbx
xchg   %ax,%ax
mov    0x8(%rsp),%rax
add    %r12,%rax
movsd  (%r14,%rax,8),%xmm2
cmp    $0x2,%r8d
jae    1ac0 <fb_once+0x980>
xor    %ecx,%ecx
jmp    1bc0 <fb_once+0xa80>
nopl   0x0(%rax,%rax,1)
mov    %r12d,%r11d
imul   %r8d,%r11d
add    0x20(%rsp),%r11d
lea    (%r11,%rsi,1),%eax
cmp    %r11d,%eax
jl     1ba0 <fb_once+0xa60>
mov    %rsi,%rax
shr    $0x20,%rax
mov    $0x0,%ecx
jne    1bc0 <fb_once+0xa80>
mov    %r12,%rax
imul   0x18(%rsp),%rax
mov    0x30(%rsp),%rsi
lea    (%rsi,%rax,8),%r8
add    %r15,%rax
lea    (%rsi,%rax,8),%rax
movslq %r11d,%rsi
lea    (%rbx,%rsi,8),%rdi
mov    0x78(%rsp),%rcx
lea    (%rcx,%rsi,8),%rsi
cmp    %rsi,%r8
setb   %cl
cmp    %rax,%rdi
setb   %r8b
cmp    %rsi,%rdx
setb   %al
cmp    0x40(%rsp),%rdi
setb   %r11b
test   %r8b,%cl
jne    1ba4 <fb_once+0xa64>
mov    $0x0,%ecx
and    %r11b,%al
mov    0x4(%rsp),%r8d
mov    0x60(%rsp),%rsi
mov    0x58(%rsp),%rdi
jne    1bc0 <fb_once+0xa80>
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movupd 0x0(%r13,%rcx,8),%xmm4
mulpd  %xmm3,%xmm4
movupd (%rdx,%rcx,8),%xmm5
mulpd  %xmm4,%xmm5
movupd (%r10,%rcx,8),%xmm4
mulpd  %xmm5,%xmm4
divpd  %xmm1,%xmm4
lea    (%r9,%rcx,1),%eax
cltq
movupd %xmm4,(%rbx,%rax,8)
add    $0x2,%rcx
cmp    %rcx,%rbp
jne    1b60 <fb_once+0xa20>
mov    %rbp,%rcx
cmp    %r15,%rbp
jne    1bc0 <fb_once+0xa80>
jmp    1bee <fb_once+0xaae>
xor    %ecx,%ecx
jmp    1bc0 <fb_once+0xa80>
xor    %ecx,%ecx
mov    0x4(%rsp),%r8d
mov    0x60(%rsp),%rsi
mov    0x58(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%r13,%rcx,8),%xmm3
mulsd  %xmm2,%xmm3
mulsd  (%rdx,%rcx,8),%xmm3
mulsd  (%r10,%rcx,8),%xmm3
divsd  %xmm0,%xmm3
lea    (%r9,%rcx,1),%eax
cltq
movsd  %xmm3,(%rbx,%rax,8)
add    $0x1,%rcx
cmp    %rcx,%r15
jne    1bc0 <fb_once+0xa80>
add    $0x1,%r12
add    %rdi,%r13
add    %r15,%r9
cmp    %r15,%r12
jne    1aa0 <fb_once+0x960>
mov    0x38(%rsp),%rax
mov    %rax,%rcx
mov    0x50(%rsp),%r12
mov    0x48(%rsp),%rbx
jmp    1a27 <fb_once+0x8e7>
cmpl   $0x0,0x10(%rsp)
mov    0x90(%rsp),%r15
mov    0x88(%rsp),%rbx
jle    1c66 <fb_once+0xb26>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rbp,8),%xmm0
call   1060 <log@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  (%r15),%xmm0
movsd  %xmm0,(%r15)
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1c40 <fb_once+0xb00>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
xor    %esi,%esi
mov    0x38(%rsp),%rax
test   $0x1,%dl
jne    1969 <fb_once+0x829>
jmp    1995 <fb_once+0x855>
xor    %esi,%esi
test   $0x1,%dl
jne    1331 <fb_once+0x1f1>
jmp    1341 <fb_once+0x201>

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

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