#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*/ assert(int);
double linemin_backtrack(double (*fun)(const double *, void *), int dim,
                         double *x, double *xnew, double *direct, void *info,
                         const double min, const double max, const double tol,
                         int *neval) {
  assert(NULL != fun);
  assert(dim > 1);
  assert(NULL != x);
  assert(NULL != xnew);
  assert(NULL != direct);
  assert(NULL != info);
  assert(min < max);
  assert(tol >= 0.);
  double range = max - min;
  for (int i = 0; i < dim; i++) {
    xnew[i] = x[i] + min * direct[i];
  }
  double fmin = fun(xnew, info);
  *neval = *neval + 1;
  double fact = 2.;
  double f;
  do {
    fact /= 2.;
    for (int i = 0; i < dim; i++) {
      xnew[i] = x[i] + (min + fact * range) * direct[i];
    }
    f = fun(xnew, info);
    *neval = *neval + 1;
  } while (f > fmin && fact > tol);
  if (fact > tol) {
    do {
      fmin = f;
      fact /= 2.;
      for (int i = 0; i < dim; i++) {
        xnew[i] = x[i] + (min + fact * range) * direct[i];
      }
      f = fun(xnew, info);
      *neval = *neval + 1;
    } while (f < fmin && fact > tol);
    if (fact > tol) {
      for (int i = 0; i < dim; i++) {
        xnew[i] = x[i] + (min + 2. * fact * range) * direct[i];
      }
      f = fmin;
    }
  }
  for (int i = 0; i < dim; i++) {
    x[i] = xnew[i];
  }
  return f;
}


x86 assembly (clang, -O0):
<linemin_backtrack>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
movsd  %xmm1,-0x40(%rbp)
movsd  %xmm2,-0x48(%rbp)
xor    %eax,%eax
cmp    -0x8(%rbp),%rax
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
cmpl   $0x1,-0xc(%rbp)
setg   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
cmp    -0x18(%rbp),%rax
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
cmp    -0x20(%rbp),%rax
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
cmp    -0x28(%rbp),%rax
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
cmp    -0x30(%rbp),%rax
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movsd  -0x38(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
setae  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movsd  -0x40(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    124d <linemin_backtrack+0x13d>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x38(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    11ff <linemin_backtrack+0xef>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   *%rax
movsd  %xmm0,-0x60(%rbp)
mov    0x10(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
movsd  0xd89(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  0xd77(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12f9 <linemin_backtrack+0x1e9>
mov    -0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x38(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm3
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1299 <linemin_backtrack+0x189>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   *%rax
movsd  %xmm0,-0x70(%rbp)
mov    0x10(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
movsd  -0x70(%rbp),%xmm0
xor    %eax,%eax
ucomisd -0x60(%rbp),%xmm0
mov    %al,-0x81(%rbp)
jbe    1346 <linemin_backtrack+0x236>
movsd  -0x68(%rbp),%xmm0
ucomisd -0x48(%rbp),%xmm0
seta   %al
mov    %al,-0x81(%rbp)
mov    -0x81(%rbp),%al
test   $0x1,%al
jne    127c <linemin_backtrack+0x16c>
movsd  -0x68(%rbp),%xmm0
ucomisd -0x48(%rbp),%xmm0
jbe    14dd <linemin_backtrack+0x3cd>
jmp    1369 <linemin_backtrack+0x259>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  0xc80(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13f0 <linemin_backtrack+0x2e0>
mov    -0x18(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x38(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm3
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1390 <linemin_backtrack+0x280>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   *%rax
movsd  %xmm0,-0x70(%rbp)
mov    0x10(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
movsd  -0x70(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
xor    %eax,%eax
ucomisd %xmm1,%xmm0
mov    %al,-0x82(%rbp)
jbe    1441 <linemin_backtrack+0x331>
movsd  -0x68(%rbp),%xmm0
ucomisd -0x48(%rbp),%xmm0
seta   %al
mov    %al,-0x82(%rbp)
mov    -0x82(%rbp),%al
test   $0x1,%al
jne    1369 <linemin_backtrack+0x259>
movsd  -0x68(%rbp),%xmm0
ucomisd -0x48(%rbp),%xmm0
jbe    14d8 <linemin_backtrack+0x3c8>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14ce <linemin_backtrack+0x3be>
mov    -0x18(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x38(%rbp),%xmm2
movsd  0xb74(%rip),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm3
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1466 <linemin_backtrack+0x356>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    14dd <linemin_backtrack+0x3cd>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1518 <linemin_backtrack+0x408>
mov    -0x20(%rbp),%rax
movslq -0x80(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x80(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    14e4 <linemin_backtrack+0x3d4>
movsd  -0x70(%rbp),%xmm0
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<linemin_backtrack>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
movsd  %xmm2,0x18(%rsp)
movsd  %xmm1,0x10(%rsp)
movaps %xmm0,0x60(%rsp)
mov    %r9,%r12
mov    %r8,%rbp
mov    %rcx,%rbx
mov    %rdx,%r14
mov    %esi,%r13d
mov    %rdi,%rax
xor    %edi,%edi
mov    %rax,0x50(%rsp)
test   %rax,%rax
setne  %dil
call   1030 <assert@plt>
xor    %edi,%edi
cmp    $0x2,%r13d
setge  %dil
call   1030 <assert@plt>
xor    %edi,%edi
test   %r14,%r14
setne  %dil
call   1030 <assert@plt>
xor    %edi,%edi
test   %rbx,%rbx
setne  %dil
call   1030 <assert@plt>
xor    %edi,%edi
test   %rbp,%rbp
setne  %dil
call   1030 <assert@plt>
xor    %edi,%edi
mov    %r12,0x58(%rsp)
test   %r12,%r12
setne  %dil
call   1030 <assert@plt>
xor    %edi,%edi
movsd  0x10(%rsp),%xmm0
ucomisd 0x60(%rsp),%xmm0
seta   %dil
call   1030 <assert@plt>
xorpd  %xmm0,%xmm0
xor    %edi,%edi
movsd  0x18(%rsp),%xmm1
ucomisd %xmm0,%xmm1
setae  %dil
call   1030 <assert@plt>
movapd 0x60(%rsp),%xmm1
mov    %r13d,%r12d
test   %r13d,%r13d
jle    139c <linemin_backtrack+0x28c>
cmp    $0x4,%r13d
jae    125a <linemin_backtrack+0x14a>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%r12b
je     1212 <linemin_backtrack+0x102>
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
addsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
or     $0x1,%rax
add    %r12,%rcx
je     139c <linemin_backtrack+0x28c>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
addsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
addsd  0x8(%r14,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r12
jne    1220 <linemin_backtrack+0x110>
jmp    139c <linemin_backtrack+0x28c>
lea    (%rbx,%r12,8),%rax
lea    (%r14,%r12,8),%rcx
cmp    %rbx,%rcx
seta   %dil
lea    0x0(,%r12,8),%rcx
add    %rbp,%rcx
cmp    %r14,%rax
seta   %dl
cmp    %rbx,%rcx
seta   %cl
cmp    %rbp,%rax
seta   %sil
xor    %eax,%eax
test   %dl,%dil
jne    11ed <linemin_backtrack+0xdd>
and    %sil,%cl
jne    11ed <linemin_backtrack+0xdd>
mov    %r12d,%eax
and    $0xfffffffc,%eax
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     19e6 <linemin_backtrack+0x8d6>
mov    %rdx,%rsi
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
and    %rcx,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%r14,%rcx,8),%xmm1
movupd 0x10(%r14,%rcx,8),%xmm2
movupd 0x0(%rbp,%rcx,8),%xmm3
movupd 0x10(%rbp,%rcx,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,(%rbx,%rcx,8)
movupd %xmm4,0x10(%rbx,%rcx,8)
movupd 0x20(%r14,%rcx,8),%xmm1
movupd 0x30(%r14,%rcx,8),%xmm2
movupd 0x20(%rbp,%rcx,8),%xmm3
movupd 0x30(%rbp,%rcx,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,0x20(%rbx,%rcx,8)
movupd %xmm4,0x30(%rbx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    12e0 <linemin_backtrack+0x1d0>
test   $0x1,%dl
je     138d <linemin_backtrack+0x27d>
movupd (%r14,%rcx,8),%xmm1
movupd 0x10(%r14,%rcx,8),%xmm2
movupd 0x0(%rbp,%rcx,8),%xmm3
movupd 0x10(%rbp,%rcx,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,(%rbx,%rcx,8)
movupd %xmm4,0x10(%rbx,%rcx,8)
cmp    %r12,%rax
movapd 0x60(%rsp),%xmm1
jne    11ed <linemin_backtrack+0xdd>
movsd  0x10(%rsp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %rbx,%rdi
mov    0x58(%rsp),%rsi
call   *0x50(%rsp)
mov    0xd0(%rsp),%rax
addl   $0x1,(%rax)
movsd  %xmm0,0x48(%rsp)
lea    (%rbx,%r12,8),%rsi
lea    (%r14,%r12,8),%rax
lea    0x0(,%r12,8),%rdi
add    %rbp,%rdi
mov    %r12d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x40(%rsp)
lea    -0x4(%rcx),%rdx
mov    %rdx,0x20(%rsp)
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %rax,0x28(%rsp)
cmp    %rbx,%rax
seta   %al
cmp    %r14,%rsi
seta   %cl
and    %al,%cl
mov    %rdi,0x70(%rsp)
cmp    %rbx,%rdi
seta   %al
mov    %rsi,0x30(%rsp)
cmp    %rbp,%rsi
seta   %r15b
and    %al,%r15b
or     %cl,%r15b
mov    %rdx,%rax
mov    %rdx,0x8(%rsp)
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rdx
mov    %rdx,0x38(%rsp)
mov    %r12,%rax
neg    %rax
mov    %rax,0x78(%rsp)
movsd  0xbab(%rip),%xmm6
cs nopw 0x0(%rax,%rax,1)
nop
mulsd  0xba0(%rip),%xmm6
test   %r13d,%r13d
jle    15e5 <linemin_backtrack+0x4d5>
mov    %r13d,%eax
cmp    $0x4,%r13d
setb   %al
movapd %xmm6,%xmm0
mulsd  0x10(%rsp),%xmm0
addsd  0x60(%rsp),%xmm0
or     %r15b,%al
je     14a0 <linemin_backtrack+0x390>
xor    %ecx,%ecx
jmp    157a <linemin_backtrack+0x46a>
nopw   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x20(%rsp)
mov    0x8(%rsp),%rdx
je     1624 <linemin_backtrack+0x514>
mov    0x38(%rsp),%rcx
xor    %eax,%eax
movupd (%r14,%rax,8),%xmm2
movupd 0x10(%r14,%rax,8),%xmm3
movupd 0x0(%rbp,%rax,8),%xmm4
movupd 0x10(%rbp,%rax,8),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,(%rbx,%rax,8)
movupd %xmm5,0x10(%rbx,%rax,8)
movupd 0x20(%r14,%rax,8),%xmm2
movupd 0x30(%r14,%rax,8),%xmm3
movupd 0x20(%rbp,%rax,8),%xmm4
movupd 0x30(%rbp,%rax,8),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,0x20(%rbx,%rax,8)
movupd %xmm5,0x30(%rbx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    14c0 <linemin_backtrack+0x3b0>
test   $0x1,%dl
je     156d <linemin_backtrack+0x45d>
movupd (%r14,%rax,8),%xmm2
movupd 0x10(%r14,%rax,8),%xmm3
movupd 0x0(%rbp,%rax,8),%xmm4
movupd 0x10(%rbp,%rax,8),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,(%rbx,%rax,8)
movupd %xmm5,0x10(%rbx,%rax,8)
mov    0x40(%rsp),%rax
mov    %rax,%rcx
cmp    %r12,%rax
je     15e5 <linemin_backtrack+0x4d5>
mov    %rcx,%rax
test   $0x1,%r12b
je     159f <linemin_backtrack+0x48f>
movsd  0x0(%rbp,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r14,%rcx,8),%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x78(%rsp),%rcx
je     15e5 <linemin_backtrack+0x4d5>
nopl   0x0(%rax)
movsd  0x0(%rbp,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r14,%rax,8),%xmm1
movsd  %xmm1,(%rbx,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%r14,%rax,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r12
jne    15b0 <linemin_backtrack+0x4a0>
mov    %rbx,%rdi
mov    0x58(%rsp),%rsi
movapd %xmm6,0x80(%rsp)
call   *0x50(%rsp)
movapd 0x80(%rsp),%xmm6
mov    0xd0(%rsp),%rax
addl   $0x1,(%rax)
ucomisd 0x48(%rsp),%xmm0
jbe    1634 <linemin_backtrack+0x524>
ucomisd 0x18(%rsp),%xmm6
ja     1460 <linemin_backtrack+0x350>
jmp    1634 <linemin_backtrack+0x524>
xor    %eax,%eax
test   $0x1,%dl
jne    1539 <linemin_backtrack+0x429>
jmp    156d <linemin_backtrack+0x45d>
ucomisd 0x18(%rsp),%xmm6
mov    %r13d,%esi
jbe    1a40 <linemin_backtrack+0x930>
cmp    %rbx,0x28(%rsp)
seta   %al
mov    0x30(%rsp),%rdx
cmp    %r14,%rdx
seta   %cl
and    %al,%cl
cmp    %rbx,0x70(%rsp)
seta   %al
cmp    %rbp,%rdx
seta   %r15b
and    %al,%r15b
or     %cl,%r15b
mov    %r12d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x40(%rsp)
mov    0x8(%rsp),%rcx
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rcx
mov    %rcx,0x38(%rsp)
nop
movsd  %xmm0,0x48(%rsp)
mulsd  0x96a(%rip),%xmm6
test   %esi,%esi
jle    1815 <linemin_backtrack+0x705>
cmp    $0x4,%esi
setb   %al
movapd %xmm6,%xmm0
mulsd  0x10(%rsp),%xmm0
addsd  0x60(%rsp),%xmm0
or     %r15b,%al
je     16d0 <linemin_backtrack+0x5c0>
xor    %ecx,%ecx
jmp    17aa <linemin_backtrack+0x69a>
nopl   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x20(%rsp)
mov    0x8(%rsp),%rdx
je     185b <linemin_backtrack+0x74b>
mov    0x38(%rsp),%rcx
xor    %eax,%eax
movupd (%r14,%rax,8),%xmm2
movupd 0x10(%r14,%rax,8),%xmm3
movupd 0x0(%rbp,%rax,8),%xmm4
movupd 0x10(%rbp,%rax,8),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,(%rbx,%rax,8)
movupd %xmm5,0x10(%rbx,%rax,8)
movupd 0x20(%r14,%rax,8),%xmm2
movupd 0x30(%r14,%rax,8),%xmm3
movupd 0x20(%rbp,%rax,8),%xmm4
movupd 0x30(%rbp,%rax,8),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,0x20(%rbx,%rax,8)
movupd %xmm5,0x30(%rbx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    16f0 <linemin_backtrack+0x5e0>
test   $0x1,%dl
je     179d <linemin_backtrack+0x68d>
movupd (%r14,%rax,8),%xmm2
movupd 0x10(%r14,%rax,8),%xmm3
movupd 0x0(%rbp,%rax,8),%xmm4
movupd 0x10(%rbp,%rax,8),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,(%rbx,%rax,8)
movupd %xmm5,0x10(%rbx,%rax,8)
mov    0x40(%rsp),%rax
mov    %rax,%rcx
cmp    %r12,%rax
je     1815 <linemin_backtrack+0x705>
mov    %rcx,%rax
test   $0x1,%r12b
je     17cf <linemin_backtrack+0x6bf>
movsd  0x0(%rbp,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r14,%rcx,8),%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x78(%rsp),%rcx
je     1815 <linemin_backtrack+0x705>
nopl   0x0(%rax)
movsd  0x0(%rbp,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r14,%rax,8),%xmm1
movsd  %xmm1,(%rbx,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%r14,%rax,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r12
jne    17e0 <linemin_backtrack+0x6d0>
mov    %rbx,%rdi
mov    0x58(%rsp),%rsi
movapd %xmm6,0x80(%rsp)
call   *0x50(%rsp)
movapd 0x80(%rsp),%xmm6
mov    %r13d,%esi
mov    0xd0(%rsp),%rax
addl   $0x1,(%rax)
movsd  0x48(%rsp),%xmm5
ucomisd %xmm0,%xmm5
jbe    186b <linemin_backtrack+0x75b>
ucomisd 0x18(%rsp),%xmm6
ja     1690 <linemin_backtrack+0x580>
jmp    186b <linemin_backtrack+0x75b>
xor    %eax,%eax
test   $0x1,%dl
jne    1769 <linemin_backtrack+0x659>
jmp    179d <linemin_backtrack+0x68d>
ucomisd 0x18(%rsp),%xmm6
jbe    1a40 <linemin_backtrack+0x930>
test   %esi,%esi
jle    1bac <linemin_backtrack+0xa9c>
addsd  %xmm6,%xmm6
mulsd  0x10(%rsp),%xmm6
addsd  0x60(%rsp),%xmm6
cmp    $0x4,%esi
jae    190a <linemin_backtrack+0x7fa>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%r12b
je     18bb <linemin_backtrack+0x7ab>
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
or     $0x1,%rax
add    %r12,%rcx
je     1a3c <linemin_backtrack+0x92c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  0x8(%r14,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r12
jne    18d0 <linemin_backtrack+0x7c0>
jmp    1a3c <linemin_backtrack+0x92c>
cmp    %rbx,0x28(%rsp)
seta   %dil
mov    0x30(%rsp),%rax
cmp    %r14,%rax
seta   %dl
cmp    %rbx,0x70(%rsp)
seta   %cl
cmp    %rbp,%rax
seta   %r8b
xor    %eax,%eax
test   %dl,%dil
jne    1896 <linemin_backtrack+0x786>
and    %r8b,%cl
jne    1896 <linemin_backtrack+0x786>
mov    %r12d,%eax
and    $0xfffffffc,%eax
movapd %xmm6,%xmm0
unpcklpd %xmm6,%xmm0
cmpq   $0x0,0x20(%rsp)
je     19f6 <linemin_backtrack+0x8e6>
mov    0x8(%rsp),%rdx
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
and    %rcx,%rdx
xor    %ecx,%ecx
nop
movupd (%r14,%rcx,8),%xmm1
movupd 0x10(%r14,%rcx,8),%xmm2
movupd 0x0(%rbp,%rcx,8),%xmm3
movupd 0x10(%rbp,%rcx,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,(%rbx,%rcx,8)
movupd %xmm4,0x10(%rbx,%rcx,8)
movupd 0x20(%r14,%rcx,8),%xmm1
movupd 0x30(%r14,%rcx,8),%xmm2
movupd 0x20(%rbp,%rcx,8),%xmm3
movupd 0x30(%rbp,%rcx,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,0x20(%rbx,%rcx,8)
movupd %xmm4,0x30(%rbx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1970 <linemin_backtrack+0x860>
jmp    19f8 <linemin_backtrack+0x8e8>
xor    %ecx,%ecx
test   $0x1,%dl
jne    1359 <linemin_backtrack+0x249>
jmp    138d <linemin_backtrack+0x27d>
xor    %ecx,%ecx
testb  $0x1,0x8(%rsp)
je     1a33 <linemin_backtrack+0x923>
movupd (%r14,%rcx,8),%xmm1
movupd 0x10(%r14,%rcx,8),%xmm2
movupd 0x0(%rbp,%rcx,8),%xmm3
movupd 0x10(%rbp,%rcx,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,(%rbx,%rcx,8)
movupd %xmm4,0x10(%rbx,%rcx,8)
cmp    %r12,%rax
jne    1896 <linemin_backtrack+0x786>
movapd %xmm5,%xmm0
test   %esi,%esi
jle    1ba8 <linemin_backtrack+0xa98>
cmp    $0x4,%esi
jb     1a5b <linemin_backtrack+0x94b>
cmp    %r14,0x30(%rsp)
jbe    1ad0 <linemin_backtrack+0x9c0>
cmp    %rbx,0x28(%rsp)
jbe    1ad0 <linemin_backtrack+0x9c0>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r12,%rcx
mov    %r12,%rdx
and    $0x3,%rdx
je     1a85 <linemin_backtrack+0x975>
nop
movsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1a70 <linemin_backtrack+0x960>
cmp    $0x3,%rcx
jb     1ba8 <linemin_backtrack+0xa98>
nop
movsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%r14,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x8(%r14,%rax,8)
movsd  0x10(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x10(%r14,%rax,8)
movsd  0x18(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x18(%r14,%rax,8)
add    $0x4,%rax
cmp    %rax,%r12
jne    1a90 <linemin_backtrack+0x980>
jmp    1ba8 <linemin_backtrack+0xa98>
mov    %r12d,%eax
and    $0xfffffffc,%eax
mov    0x8(%rsp),%rsi
mov    %esi,%ecx
and    $0x3,%ecx
cmpq   $0xc,0x20(%rsp)
jae    1aec <linemin_backtrack+0x9dc>
xor    %edx,%edx
jmp    1b64 <linemin_backtrack+0xa54>
movabs $0x7ffffffffffffffe,%rdx
ff ff 7f
add    $0xfffffffffffffffe,%rdx
and    %rdx,%rsi
xor    %edx,%edx
nop
movups (%rbx,%rdx,8),%xmm1
movups 0x10(%rbx,%rdx,8),%xmm2
movups %xmm1,(%r14,%rdx,8)
movups %xmm2,0x10(%r14,%rdx,8)
movups 0x20(%rbx,%rdx,8),%xmm1
movups 0x30(%rbx,%rdx,8),%xmm2
movups %xmm1,0x20(%r14,%rdx,8)
movups %xmm2,0x30(%r14,%rdx,8)
movups 0x40(%rbx,%rdx,8),%xmm1
movups 0x50(%rbx,%rdx,8),%xmm2
movups %xmm1,0x40(%r14,%rdx,8)
movups %xmm2,0x50(%r14,%rdx,8)
movupd 0x60(%rbx,%rdx,8),%xmm1
movupd 0x70(%rbx,%rdx,8),%xmm2
movupd %xmm1,0x60(%r14,%rdx,8)
movupd %xmm2,0x70(%r14,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rsi
jne    1b00 <linemin_backtrack+0x9f0>
test   %rcx,%rcx
je     1b9f <linemin_backtrack+0xa8f>
lea    (%r14,%rdx,8),%rsi
add    $0x10,%rsi
lea    (%rbx,%rdx,8),%rdx
add    $0x10,%rdx
shl    $0x5,%rcx
xor    %edi,%edi
nop
movupd -0x10(%rdx,%rdi,1),%xmm1
movupd (%rdx,%rdi,1),%xmm2
movupd %xmm1,-0x10(%rsi,%rdi,1)
movupd %xmm2,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    1b80 <linemin_backtrack+0xa70>
cmp    %r12,%rax
jne    1a5d <linemin_backtrack+0x94d>
movapd %xmm0,%xmm5
movapd %xmm5,%xmm0
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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