#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 fabs(double);
double sqrt(double);
void refine_fast_s(double **x, double *y, double *weights, int n, int p,
                   double *res, double *tmp, double *tmp2, double **tmp_mat,
                   double **tmp_mat2, double *beta_cand, int kk, int conv,
                   double b, double rhoc, double *is, double *beta_ref,
                   double *scale) {
  void fast_s_irwls(double **x, double *y, double *weights, int n, int p,
                    double *beta_ref, double **tmp_mat, double *tmp,
                    double *tmp2);
  double norm_diff(double *x, double *y, int n);
  double norm(double *x, int n);
  int lu(double **a, int *P, double *x);
  void get_weights_rhop(double *r, double s, int n, double rhoc, double *w);
  void r_sum_w_x(double **x, double *w, int n, int p, double *tmp, double *sum);
  void r_sum_w_x_xprime(double **x, double *w, int n, int p, double **tmp,
                        double **ans);
  double loss_rho(double *r, double scale, int n, int p, double rhoc);
  double MAD(double *a, int n, int center, double *tmp, double *tmp2);
  double vecprime_vec(double *a, double *b, int n);
  register int i, j;
  int zeroes = 0;
  double initial_scale = *is, s0;
  for (j = 0; j < n; j++)
    if (fabs(res[j] = y[j] - vecprime_vec(x[j], beta_cand, p)) < 1e-10)
      zeroes++;
  if (zeroes > ((double)n / 2.)) {
    for (i = 0; i < p; i++)
      beta_ref[i] = beta_cand[i];
    *scale = 0.0;
    return;
  };
  if (initial_scale < 0.0)
    initial_scale = MAD(res, n, 0, tmp, tmp2);
  s0 = initial_scale;
  if (conv > 0)
    kk = 500;
  if (kk > 0) {
    for (i = 0; i < kk; i++) {
      s0 = s0 * sqrt(loss_rho(res, s0, n, p, rhoc) / b);
      get_weights_rhop(res, s0, n, rhoc, weights);
      r_sum_w_x_xprime(x, weights, n, p, tmp_mat, tmp_mat2);
      for (j = 0; j < n; j++)
        weights[j] = weights[j] * y[j];
      r_sum_w_x(x, weights, n, p, tmp, tmp2);
      for (j = 0; j < p; j++)
        tmp_mat2[j][p] = tmp2[j];
      lu(tmp_mat2, &p, beta_ref);
      if (conv > 0) {
        if (norm_diff(beta_cand, beta_ref, p) / norm(beta_cand, p) < 1e-20) {
          break;
        };
      };
      for (j = 0; j < n; j++)
        res[j] = y[j] - vecprime_vec(x[j], beta_ref, p);
      for (j = 0; j < p; j++)
        beta_cand[j] = beta_ref[j];
    };
  };
  *scale = s0;
}


x86 assembly (clang, -O0):
<refine_fast_s>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
movsd  %xmm1,-0x38(%rbp)
movl   $0x0,-0x44(%rbp)
mov    0x48(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12a3 <refine_fast_s+0xf3>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    0x30(%rbp),%rsi
mov    -0x20(%rbp),%edx
call   10b0 <vecprime_vec@plt>
movaps %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
call   1080 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0xd93(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1290 <refine_fast_s+0xe0>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1295 <refine_fast_s+0xe5>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    121d <refine_fast_s+0x6d>
cvtsi2sdl -0x44(%rbp),%xmm0
cvtsi2sdl -0x1c(%rbp),%xmm1
movsd  0xd4b(%rip),%xmm2
divsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    130e <refine_fast_s+0x15e>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12fe <refine_fast_s+0x14e>
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12ca <refine_fast_s+0x11a>
mov    0x58(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
jmp    15ad <refine_fast_s+0x3fd>
xorps  %xmm0,%xmm0
ucomisd -0x50(%rbp),%xmm0
jbe    1337 <refine_fast_s+0x187>
mov    -0x28(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    0x10(%rbp),%rcx
mov    0x18(%rbp),%r8
xor    %edx,%edx
call   1040 <MAD@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
cmpl   $0x0,0x40(%rbp)
jle    1352 <refine_fast_s+0x1a2>
movl   $0x1f4,0x38(%rbp)
cmpl   $0x0,0x38(%rbp)
jle    15a0 <refine_fast_s+0x3f0>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    159b <refine_fast_s+0x3eb>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%rdi
movsd  -0x58(%rbp),%xmm0
mov    -0x1c(%rbp),%esi
mov    -0x20(%rbp),%edx
movsd  -0x38(%rbp),%xmm1
call   10c0 <loss_rho@plt>
divsd  -0x30(%rbp),%xmm0
call   10d0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%rdi
movsd  -0x58(%rbp),%xmm0
mov    -0x1c(%rbp),%esi
movsd  -0x38(%rbp),%xmm1
mov    -0x18(%rbp),%rdx
call   1030 <get_weights_rhop@plt>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    0x20(%rbp),%r8
mov    0x28(%rbp),%r9
call   10a0 <r_sum_w_x_xprime@plt>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    142a <refine_fast_s+0x27a>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    13e9 <refine_fast_s+0x239>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    0x10(%rbp),%r8
mov    0x18(%rbp),%r9
call   1070 <r_sum_w_x@plt>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1488 <refine_fast_s+0x2d8>
mov    0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    144c <refine_fast_s+0x29c>
mov    0x28(%rbp),%rdi
mov    0x50(%rbp),%rdx
lea    -0x20(%rbp),%rsi
call   1060 <lu@plt>
cmpl   $0x0,0x40(%rbp)
jle    14e9 <refine_fast_s+0x339>
mov    0x30(%rbp),%rdi
mov    0x50(%rbp),%rsi
mov    -0x20(%rbp),%edx
call   1050 <norm_diff@plt>
movsd  %xmm0,-0x70(%rbp)
mov    0x30(%rbp),%rdi
mov    -0x20(%rbp),%esi
call   1090 <norm@plt>
movsd  -0x70(%rbp),%xmm1
divsd  %xmm0,%xmm1
movsd  0xb33(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    14e4 <refine_fast_s+0x334>
jmp    159b <refine_fast_s+0x3eb>
jmp    14e9 <refine_fast_s+0x339>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    154d <refine_fast_s+0x39d>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    0x50(%rbp),%rsi
mov    -0x20(%rbp),%edx
call   10b0 <vecprime_vec@plt>
movaps %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
subsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    14f0 <refine_fast_s+0x340>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1588 <refine_fast_s+0x3d8>
mov    0x50(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1554 <refine_fast_s+0x3a4>
jmp    158d <refine_fast_s+0x3dd>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1363 <refine_fast_s+0x1b3>
jmp    15a0 <refine_fast_s+0x3f0>
movsd  -0x58(%rbp),%xmm0
mov    0x58(%rbp),%rax
movsd  %xmm0,(%rax)
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<refine_fast_s>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
movsd  %xmm1,0x40(%rsp)
movsd  %xmm0,0x88(%rsp)
mov    %r9,0x18(%rsp)
mov    %r8d,%r13d
mov    %rdx,%r12
mov    %rsi,%r14
mov    %rdi,0x30(%rsp)
mov    0xf0(%rsp),%rbp
mov    0x108(%rsp),%rax
mov    %r8d,0x4(%rsp)
movsd  (%rax),%xmm0
movsd  %xmm0,0x10(%rsp)
test   %ecx,%ecx
mov    %ecx,0xc(%rsp)
jle    1282 <refine_fast_s+0xd2>
mov    %ecx,%eax
mov    %rax,0x28(%rsp)
xor    %ebx,%ebx
xor    %ebp,%ebp
mov    0x30(%rsp),%r15
nopw   0x0(%rax,%rax,1)
movsd  (%r14,%rbx,8),%xmm0
movsd  %xmm0,0x20(%rsp)
mov    (%r15,%rbx,8),%rdi
mov    0xf0(%rsp),%rsi
mov    %r13d,%edx
call   10b0 <vecprime_vec@plt>
movsd  0x20(%rsp),%xmm1
subsd  %xmm0,%xmm1
mov    0x18(%rsp),%rax
movsd  %xmm1,(%rax,%rbx,8)
movapd %xmm1,%xmm0
call   1080 <fabs@plt>
xor    %ecx,%ecx
test   %eax,%eax
setle  %cl
add    %ecx,%ebp
add    $0x1,%rbx
cmp    %rbx,0x28(%rsp)
jne    1220 <refine_fast_s+0x70>
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
mov    0xf0(%rsp),%rbp
jmp    1286 <refine_fast_s+0xd6>
xorpd  %xmm0,%xmm0
mov    0x110(%rsp),%rbx
xorps  %xmm1,%xmm1
cvtsi2sdl 0xc(%rsp),%xmm1
mulsd  0xd61(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    135d <refine_fast_s+0x1ad>
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x10(%rsp)
test   %r13d,%r13d
jle    1ad0 <refine_fast_s+0x920>
mov    %r13d,%eax
cmp    $0x4,%r13d
jb     12e6 <refine_fast_s+0x136>
lea    0x0(,%rax,8),%rcx
add    %rbp,%rcx
cmp    %rbx,%rcx
jbe    19dd <refine_fast_s+0x82d>
lea    (%rbx,%rax,8),%rcx
cmp    %rbp,%rcx
jbe    19dd <refine_fast_s+0x82d>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     1315 <refine_fast_s+0x165>
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1300 <refine_fast_s+0x150>
cmp    $0x3,%rdx
jb     1ad0 <refine_fast_s+0x920>
nop
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rcx,8)
movsd  0x10(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rcx,8)
movsd  0x18(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1320 <refine_fast_s+0x170>
jmp    1ad0 <refine_fast_s+0x920>
mov    0xf8(%rsp),%ebx
xorpd  %xmm0,%xmm0
ucomisd 0x10(%rsp),%xmm0
jbe    1396 <refine_fast_s+0x1e6>
mov    0x18(%rsp),%rdi
mov    0xc(%rsp),%esi
xor    %edx,%edx
mov    0xd0(%rsp),%rcx
mov    0xd8(%rsp),%r8
call   1040 <MAD@plt>
movsd  %xmm0,0x10(%rsp)
cmpl   $0x0,0x100(%rsp)
mov    $0x1f4,%eax
cmovg  %eax,%ebx
mov    %ebx,0x3c(%rsp)
test   %ebx,%ebx
jle    1ad0 <refine_fast_s+0x920>
movabs $0x7ffffffffffffffc,%rdx
ff ff 7f
mov    0xc(%rsp),%ebx
lea    (%r12,%rbx,8),%rax
lea    (%r14,%rbx,8),%rcx
mov    %ebx,%esi
and    $0xfffffffc,%esi
mov    %rsi,0x70(%rsp)
add    $0xfffffffffffffffc,%rsi
mov    %rsi,0x68(%rsp)
shr    $0x2,%rsi
add    $0x1,%rsi
cmp    %r12,%rcx
seta   %cl
cmp    %r14,%rax
seta   %al
and    %cl,%al
mov    %al,0xb(%rsp)
lea    0x2(%rdx),%rcx
mov    %rsi,%rax
mov    %rsi,0x60(%rsp)
and    %rsi,%rcx
mov    %rcx,0x58(%rsp)
mov    %ebx,%eax
and    $0x3,%eax
mov    %rax,0x78(%rsp)
lea    0x10(%rbp),%rax
mov    %rax,0x50(%rsp)
mov    0x110(%rsp),%rax
add    $0x10,%rax
mov    %rax,0x48(%rsp)
xor    %r15d,%r15d
mov    %rbx,0x28(%rsp)
mov    %r12,0x80(%rsp)
jmp    1454 <refine_fast_s+0x2a4>
nop
add    $0x1,%r15d
cmp    0x3c(%rsp),%r15d
mov    0x28(%rsp),%rbx
je     1ad0 <refine_fast_s+0x920>
mov    0x18(%rsp),%rdi
movsd  0x10(%rsp),%xmm0
mov    0xc(%rsp),%ebp
mov    %ebp,%esi
mov    %r13d,%edx
movsd  0x40(%rsp),%xmm1
call   10c0 <loss_rho@plt>
divsd  0x88(%rsp),%xmm0
ucomisd 0xb8c(%rip),%xmm0
jb     1490 <refine_fast_s+0x2e0>
sqrtsd %xmm0,%xmm0
jmp    1495 <refine_fast_s+0x2e5>
nopl   0x0(%rax)
call   10d0 <sqrt@plt>
mov    0x18(%rsp),%rdi
mov    0x30(%rsp),%r13
movsd  0x10(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
movapd %xmm1,%xmm0
mov    %ebp,%esi
movsd  0x40(%rsp),%xmm1
mov    %r12,%rdx
call   1030 <get_weights_rhop@plt>
mov    0x4(%rsp),%ecx
mov    %r13,%rdi
mov    %r12,%rsi
mov    %ebp,%edx
mov    0xe0(%rsp),%r8
mov    0xe8(%rsp),%r9
call   10a0 <r_sum_w_x_xprime@plt>
test   %ebp,%ebp
jle    167a <refine_fast_s+0x4ca>
cmp    $0x4,%ebp
setb   %al
or     0xb(%rsp),%al
je     1500 <refine_fast_s+0x350>
xor    %eax,%eax
jmp    15d2 <refine_fast_s+0x422>
nop
cmpq   $0x0,0x68(%rsp)
je     1904 <refine_fast_s+0x754>
mov    0x58(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%r14,%rax,8),%xmm0
movupd 0x10(%r14,%rax,8),%xmm1
movupd (%r12,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r12,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd 0x20(%r12,%rax,8),%xmm1
movupd 0x30(%r12,%rax,8),%xmm3
movupd %xmm2,(%r12,%rax,8)
movupd %xmm0,0x10(%r12,%rax,8)
movupd 0x20(%r14,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd 0x30(%r14,%rax,8),%xmm1
mulpd  %xmm3,%xmm1
movupd %xmm0,0x20(%r12,%rax,8)
movupd %xmm1,0x30(%r12,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1520 <refine_fast_s+0x370>
testb  $0x1,0x60(%rsp)
je     15c1 <refine_fast_s+0x411>
movupd (%r12,%rax,8),%xmm0
movupd 0x10(%r12,%rax,8),%xmm1
movupd (%r14,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r14,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r12,%rax,8)
movupd %xmm0,0x10(%r12,%rax,8)
mov    0x70(%rsp),%rcx
mov    %rcx,%rax
cmp    %rbx,%rcx
je     167a <refine_fast_s+0x4ca>
mov    %rax,%rcx
not    %rcx
add    %rbx,%rcx
mov    0x78(%rsp),%rdx
test   %rdx,%rdx
je     160c <refine_fast_s+0x45c>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r12,%rax,8),%xmm0
mulsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    15f0 <refine_fast_s+0x440>
cmp    $0x3,%rcx
jb     167a <refine_fast_s+0x4ca>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r12,%rax,8),%xmm0
mulsd  (%r14,%rax,8),%xmm0
movsd  0x8(%r12,%rax,8),%xmm1
movsd  %xmm0,(%r12,%rax,8)
mulsd  0x8(%r14,%rax,8),%xmm1
movsd  %xmm1,0x8(%r12,%rax,8)
movsd  0x10(%r12,%rax,8),%xmm0
mulsd  0x10(%r14,%rax,8),%xmm0
movsd  %xmm0,0x10(%r12,%rax,8)
movsd  0x18(%r12,%rax,8),%xmm0
mulsd  0x18(%r14,%rax,8),%xmm0
movsd  %xmm0,0x18(%r12,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbx
jne    1620 <refine_fast_s+0x470>
mov    0x4(%rsp),%ecx
mov    %r13,%rdi
mov    %r12,%rsi
mov    %ebp,%edx
mov    0xd0(%rsp),%r8
mov    0xd8(%rsp),%r9
call   1070 <r_sum_w_x@plt>
mov    0x4(%rsp),%eax
test   %eax,%eax
mov    0xe8(%rsp),%rbx
jle    1758 <refine_fast_s+0x5a8>
lea    -0x1(%rax),%rdx
mov    %eax,%ecx
and    $0x3,%ecx
cmp    $0x3,%rdx
jae    16d0 <refine_fast_s+0x520>
xor    %edx,%edx
jmp    1728 <refine_fast_s+0x578>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %eax,%esi
and    $0xfffffffc,%esi
xor    %edx,%edx
mov    0xd8(%rsp),%rbp
nop
movsd  0x0(%rbp,%rdx,8),%xmm0
mov    (%rbx,%rdx,8),%rdi
movsd  %xmm0,(%rdi,%rax,8)
movsd  0x8(%rbp,%rdx,8),%xmm0
mov    0x8(%rbx,%rdx,8),%rdi
movsd  %xmm0,(%rdi,%rax,8)
movsd  0x10(%rbp,%rdx,8),%xmm0
mov    0x10(%rbx,%rdx,8),%rdi
movsd  %xmm0,(%rdi,%rax,8)
movsd  0x18(%rbp,%rdx,8),%xmm0
mov    0x18(%rbx,%rdx,8),%rdi
movsd  %xmm0,(%rdi,%rax,8)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    16e0 <refine_fast_s+0x530>
test   %rcx,%rcx
je     1758 <refine_fast_s+0x5a8>
lea    (%rbx,%rdx,8),%rsi
mov    0xd8(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdx
xor    %edi,%edi
nop
movsd  (%rdx,%rdi,8),%xmm0
mov    (%rsi,%rdi,8),%rbp
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    1740 <refine_fast_s+0x590>
mov    %rbx,%rdi
lea    0x4(%rsp),%rsi
mov    0x110(%rsp),%rbx
mov    %rbx,%rdx
call   1060 <lu@plt>
cmpl   $0x0,0x100(%rsp)
jle    17bf <refine_fast_s+0x60f>
mov    0x4(%rsp),%edx
mov    0xf0(%rsp),%rbp
mov    %rbp,%rdi
mov    %rbx,%rsi
call   1050 <norm_diff@plt>
movsd  %xmm0,0x20(%rsp)
mov    0x4(%rsp),%esi
mov    %rbp,%rdi
call   1090 <norm@plt>
movsd  0x20(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  0x853(%rip),%xmm0
ucomisd %xmm1,%xmm0
ja     1ad0 <refine_fast_s+0x920>
mov    %r15,0x90(%rsp)
cmpl   $0x0,0xc(%rsp)
mov    0x28(%rsp),%r15
mov    %rbx,%r12
mov    %r14,%rbx
mov    0x18(%rsp),%r14
jle    1815 <refine_fast_s+0x665>
xor    %ebp,%ebp
movsd  (%rbx,%rbp,8),%xmm0
movsd  %xmm0,0x20(%rsp)
mov    0x0(%r13,%rbp,8),%rdi
mov    0x4(%rsp),%edx
mov    %r12,%rsi
call   10b0 <vecprime_vec@plt>
movsd  0x20(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r15
jne    17e0 <refine_fast_s+0x630>
mov    0x4(%rsp),%r13d
test   %r13d,%r13d
mov    0xf0(%rsp),%rbp
mov    0x90(%rsp),%r15
mov    %rbx,%r14
mov    %r12,%rbx
mov    0x80(%rsp),%r12
jle    1440 <refine_fast_s+0x290>
cmp    $0x4,%r13d
jb     1864 <refine_fast_s+0x6b4>
lea    (%rbx,%r13,8),%rax
cmp    %rbp,%rax
jbe    18dd <refine_fast_s+0x72d>
lea    0x0(,%r13,8),%rax
add    %rbp,%rax
cmp    %rbx,%rax
jbe    18dd <refine_fast_s+0x72d>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r13,%rcx
mov    %r13,%rdx
and    $0x3,%rdx
je     1895 <refine_fast_s+0x6e5>
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1880 <refine_fast_s+0x6d0>
cmp    $0x3,%rcx
jb     1440 <refine_fast_s+0x290>
nop
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rax,8)
movsd  0x10(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbp,%rax,8)
movsd  0x18(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbp,%rax,8)
add    $0x4,%rax
cmp    %rax,%r13
jne    18a0 <refine_fast_s+0x6f0>
jmp    1440 <refine_fast_s+0x290>
mov    %r13d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0xc,%rsi
jae    1916 <refine_fast_s+0x766>
xor    %esi,%esi
jmp    198d <refine_fast_s+0x7dd>
xor    %eax,%eax
testb  $0x1,0x60(%rsp)
jne    1592 <refine_fast_s+0x3e2>
jmp    15c1 <refine_fast_s+0x411>
movabs $0x7ffffffffffffffc,%rsi
ff ff 7f
and    %rsi,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rbx,%rsi,8),%xmm0
movups 0x10(%rbx,%rsi,8),%xmm1
movups %xmm0,0x0(%rbp,%rsi,8)
movups %xmm1,0x10(%rbp,%rsi,8)
movups 0x20(%rbx,%rsi,8),%xmm0
movups 0x30(%rbx,%rsi,8),%xmm1
movups %xmm0,0x20(%rbp,%rsi,8)
movups %xmm1,0x30(%rbp,%rsi,8)
movups 0x40(%rbx,%rsi,8),%xmm0
movups 0x50(%rbx,%rsi,8),%xmm1
movups %xmm0,0x40(%rbp,%rsi,8)
movups %xmm1,0x50(%rbp,%rsi,8)
movupd 0x60(%rbx,%rsi,8),%xmm0
movupd 0x70(%rbx,%rsi,8),%xmm1
movupd %xmm0,0x60(%rbp,%rsi,8)
movupd %xmm1,0x70(%rbp,%rsi,8)
add    $0x10,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1930 <refine_fast_s+0x780>
test   %rcx,%rcx
je     19cf <refine_fast_s+0x81f>
mov    0x50(%rsp),%rdx
lea    (%rdx,%rsi,8),%rdx
mov    0x48(%rsp),%rdi
lea    (%rdi,%rsi,8),%rsi
shl    $0x5,%rcx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rsi,%rdi,1),%xmm0
movupd (%rsi,%rdi,1),%xmm1
movupd %xmm0,-0x10(%rdx,%rdi,1)
movupd %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    19b0 <refine_fast_s+0x800>
cmp    %r13,%rax
je     1440 <refine_fast_s+0x290>
jmp    1866 <refine_fast_s+0x6b6>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0xc,%rdi
jae    1a00 <refine_fast_s+0x850>
xor    %edi,%edi
jmp    1a6d <refine_fast_s+0x8bd>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movups 0x0(%rbp,%rdi,8),%xmm0
movups 0x10(%rbp,%rdi,8),%xmm1
movups %xmm0,(%rbx,%rdi,8)
movups %xmm1,0x10(%rbx,%rdi,8)
movups 0x20(%rbp,%rdi,8),%xmm0
movups 0x30(%rbp,%rdi,8),%xmm1
movups %xmm0,0x20(%rbx,%rdi,8)
movups %xmm1,0x30(%rbx,%rdi,8)
movups 0x40(%rbp,%rdi,8),%xmm0
movups 0x50(%rbp,%rdi,8),%xmm1
movups %xmm0,0x40(%rbx,%rdi,8)
movups %xmm1,0x50(%rbx,%rdi,8)
movupd 0x60(%rbp,%rdi,8),%xmm0
movupd 0x70(%rbp,%rdi,8),%xmm1
movupd %xmm0,0x60(%rbx,%rdi,8)
movupd %xmm1,0x70(%rbx,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1a10 <refine_fast_s+0x860>
test   %rdx,%rdx
je     1abf <refine_fast_s+0x90f>
lea    (%rbx,%rdi,8),%rsi
add    $0x10,%rsi
mov    0xf0(%rsp),%rbp
lea    0x10(,%rdi,8),%rdi
add    %rbp,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x10(%rdi,%rbp,1),%xmm0
movupd (%rdi,%rbp,1),%xmm1
movupd %xmm0,-0x10(%rsi,%rbp,1)
movupd %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1aa0 <refine_fast_s+0x8f0>
cmp    %rax,%rcx
mov    0xf0(%rsp),%rbp
jne    12e8 <refine_fast_s+0x138>
movsd  0x10(%rsp),%xmm0
mov    0x118(%rsp),%rax
movsd  %xmm0,(%rax)
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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