#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);
int /*<<< orphan*/ printf(char *);
void eplb(double *x, double *root, int *steps, double *v, int n, double z,
          double lambda0) {
  int i, j, flag = 0;
  int rho_1, rho_2, rho, rho_T, rho_S;
  int V_i_b, V_i_e, V_i;
  double lambda_1, lambda_2, lambda_T, lambda_S, lambda;
  double s_1, s_2, s, s_T, s_S, v_max, temp;
  double f_lambda_1, f_lambda_2, f_lambda, f_lambda_T, f_lambda_S;
  int iter_step = 0;
  if (z < 0) {
    printf("\n z should be nonnegative!");
    return;
  }
  V_i = 0;
  if (v[0] != 0) {
    rho_1 = 1;
    s_1 = x[V_i] = v_max = fabs(v[0]);
    V_i++;
  } else {
    rho_1 = 0;
    s_1 = v_max = 0;
  }
  for (i = 1; i < n; i++) {
    if (v[i] != 0) {
      x[V_i] = fabs(v[i]);
      s_1 += x[V_i];
      rho_1++;
      if (x[V_i] > v_max)
        v_max = x[V_i];
      V_i++;
    }
  }
  if (s_1 <= z) {
    flag = 1;
    lambda = 0;
    for (i = 0; i < n; i++) {
      x[i] = v[i];
    }
    *root = lambda;
    *steps = iter_step;
    return;
  }
  lambda_1 = 0;
  lambda_2 = v_max;
  f_lambda_1 = s_1 - z;
  rho_2 = 0;
  s_2 = 0;
  f_lambda_2 = -z;
  V_i_b = 0;
  V_i_e = V_i - 1;
  lambda = lambda0;
  if ((lambda < lambda_2) && (lambda > lambda_1)) {
    i = V_i_b;
    j = V_i_e;
    rho = 0;
    s = 0;
    while (i <= j) {
      while ((i <= V_i_e) && (x[i] <= lambda)) {
        i++;
      }
      while ((j >= V_i_b) && (x[j] > lambda)) {
        s += x[j];
        j--;
      }
      if (i < j) {
        s += x[i];
        temp = x[i];
        x[i] = x[j];
        x[j] = temp;
        i++;
        j--;
      }
    }
    rho = V_i_e - j;
    rho += rho_2;
    s += s_2;
    f_lambda = s - rho * lambda - z;
    if (fabs(f_lambda) < 1e-8) {
      flag = 1;
    }
    if (f_lambda < 0) {
      lambda_2 = lambda;
      s_2 = s;
      rho_2 = rho;
      f_lambda_2 = f_lambda;
      V_i_e = j;
      V_i = V_i_e - V_i_b + 1;
    } else {
      lambda_1 = lambda;
      rho_1 = rho;
      s_1 = s;
      f_lambda_1 = f_lambda;
      V_i_b = i;
      V_i = V_i_e - V_i_b + 1;
    }
    if (V_i == 0) {
      lambda = (s - z) / rho;
      flag = 1;
    }
  }
  while (!flag) {
    iter_step++;
    lambda_T = lambda_1 + f_lambda_1 / rho_1;
    if (rho_2 != 0) {
      if (lambda_2 + f_lambda_2 / rho_2 > lambda_T)
        lambda_T = lambda_2 + f_lambda_2 / rho_2;
    }
    lambda_S = lambda_2 -
               f_lambda_2 * (lambda_2 - lambda_1) / (f_lambda_2 - f_lambda_1);
    if (fabs(lambda_T - lambda_S) <= 1e-8) {
      lambda = lambda_T;
      flag = 1;
      break;
    }
    lambda = (lambda_T + lambda_S) / 2;
    s_T = s_S = s = 0;
    rho_T = rho_S = rho = 0;
    i = V_i_b;
    j = V_i_e;
    while (i <= j) {
      while ((i <= V_i_e) && (x[i] <= lambda)) {
        if (x[i] > lambda_T) {
          s_T += x[i];
          rho_T++;
        }
        i++;
      }
      while ((j >= V_i_b) && (x[j] > lambda)) {
        if (x[j] > lambda_S) {
          s_S += x[j];
          rho_S++;
        } else {
          s += x[j];
          rho++;
        }
        j--;
      }
      if (i < j) {
        if (x[i] > lambda_S) {
          s_S += x[i];
          rho_S++;
        } else {
          s += x[i];
          rho++;
        }
        if (x[j] > lambda_T) {
          s_T += x[j];
          rho_T++;
        }
        temp = x[i];
        x[i] = x[j];
        x[j] = temp;
        i++;
        j--;
      }
    }
    s_S += s_2;
    rho_S += rho_2;
    s += s_S;
    rho += rho_S;
    s_T += s;
    rho_T += rho;
    f_lambda_S = s_S - rho_S * lambda_S - z;
    f_lambda = s - rho * lambda - z;
    f_lambda_T = s_T - rho_T * lambda_T - z;
    if (fabs(f_lambda) < 1e-8) {
      flag = 1;
      break;
    }
    if (fabs(f_lambda_S) < 1e-8) {
      lambda = lambda_S;
      flag = 1;
      break;
    }
    if (fabs(f_lambda_T) < 1e-8) {
      lambda = lambda_T;
      flag = 1;
      break;
    }
    if (f_lambda < 0) {
      lambda_2 = lambda;
      s_2 = s;
      rho_2 = rho;
      f_lambda_2 = f_lambda;
      lambda_1 = lambda_T;
      s_1 = s_T;
      rho_1 = rho_T;
      f_lambda_1 = f_lambda_T;
      V_i_e = j;
      i = V_i_b;
      while (i <= j) {
        while ((i <= V_i_e) && (x[i] <= lambda_T)) {
          i++;
        }
        while ((j >= V_i_b) && (x[j] > lambda_T)) {
          j--;
        }
        if (i < j) {
          x[j] = x[i];
          i++;
          j--;
        }
      }
      V_i_b = i;
      V_i = V_i_e - V_i_b + 1;
    } else {
      lambda_1 = lambda;
      s_1 = s;
      rho_1 = rho;
      f_lambda_1 = f_lambda;
      lambda_2 = lambda_S;
      s_2 = s_S;
      rho_2 = rho_S;
      f_lambda_2 = f_lambda_S;
      V_i_b = i;
      j = V_i_e;
      while (i <= j) {
        while ((i <= V_i_e) && (x[i] <= lambda_S)) {
          i++;
        }
        while ((j >= V_i_b) && (x[j] > lambda_S)) {
          j--;
        }
        if (i < j) {
          x[i] = x[j];
          i++;
          j--;
        }
      }
      V_i_e = j;
      V_i = V_i_e - V_i_b + 1;
    }
    if (V_i == 0) {
      lambda = (s - z) / rho;
      flag = 1;
      break;
    }
  }
  for (i = 0; i < n; i++) {
    if (v[i] > lambda)
      x[i] = v[i] - lambda;
    else if (v[i] < -lambda)
      x[i] = v[i] + lambda;
    else
      x[i] = 0;
  }
  *root = lambda;
  *steps = iter_step;
}


x86 assembly (clang, -O0):
<eplb>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
movsd  %xmm0,-0x30(%rbp)
movsd  %xmm1,-0x38(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0xf4(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x30(%rbp),%xmm0
jbe    1179 <eplb+0x59>
lea    0x1ea1(%rip),%rdi
call   1030 <printf@plt>
jmp    20e2 <eplb+0xfc2>
movl   $0x0,-0x64(%rbp)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11a0 <eplb+0x80>
jp     11a0 <eplb+0x80>
jmp    11e3 <eplb+0xc3>
movl   $0x1,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1200 <eplb+0xe0>
movl   $0x0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12cd <eplb+0x1ad>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1238 <eplb+0x118>
jp     1238 <eplb+0x118>
jmp    12ba <eplb+0x19a>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0xc0(%rbp),%xmm0
ff
jbe    12b1 <eplb+0x191>
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    12bf <eplb+0x19f>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1207 <eplb+0xe7>
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0x30(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1352 <eplb+0x232>
movl   $0x1,-0x44(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1331 <eplb+0x211>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12fd <eplb+0x1dd>
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0xf4(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
jmp    20e2 <eplb+0xfc2>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movl   $0x0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movl   $0x0,-0x5c(%rbp)
mov    -0x64(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x60(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    16e1 <eplb+0x5c1>
movsd  -0x90(%rbp),%xmm0
ff
ucomisd -0x70(%rbp),%xmm0
jbe    16e1 <eplb+0x5c1>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1578 <eplb+0x458>
jmp    1428 <eplb+0x308>
mov    -0x3c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x60(%rbp),%ecx
mov    %al,-0xf5(%rbp)
jg     145e <eplb+0x33e>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
setae  %al
mov    %al,-0xf5(%rbp)
mov    -0xf5(%rbp),%al
test   $0x1,%al
jne    1471 <eplb+0x351>
jmp    147f <eplb+0x35f>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1428 <eplb+0x308>
jmp    1484 <eplb+0x364>
mov    -0x40(%rbp),%ecx
xor    %eax,%eax
cmp    -0x5c(%rbp),%ecx
mov    %al,-0xf6(%rbp)
jl     14b6 <eplb+0x396>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x90(%rbp),%xmm0
ff
seta   %al
mov    %al,-0xf6(%rbp)
mov    -0xf6(%rbp),%al
test   $0x1,%al
jne    14c9 <eplb+0x3a9>
jmp    14f4 <eplb+0x3d4>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1484 <eplb+0x364>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1573 <eplb+0x453>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1417 <eplb+0x2f7>
mov    -0x60(%rbp),%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm1
ff
cvtsi2sdl -0x50(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0x1a04(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    160d <eplb+0x4ed>
movl   $0x1,-0x44(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0xe0(%rbp),%xmm0
ff
jbe    1668 <eplb+0x548>
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x50(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x40(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
sub    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    16ad <eplb+0x58d>
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x48(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x3c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
sub    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
cmpl   $0x0,-0x64(%rbp)
jne    16dc <eplb+0x5bc>
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0x30(%rbp),%xmm0
cvtsi2sdl -0x50(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x1,-0x44(%rbp)
jmp    16e1 <eplb+0x5c1>
jmp    16e6 <eplb+0x5c6>
cmpl   $0x0,-0x44(%rbp)
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    16fc <eplb+0x5dc>
jmp    1fec <eplb+0xecc>
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm1
ff
cvtsi2sdl -0x48(%rbp),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
cmpl   $0x0,-0x4c(%rbp)
je     177d <eplb+0x65d>
movsd  -0x78(%rbp),%xmm0
movsd  -0xd8(%rbp),%xmm1
ff
cvtsi2sdl -0x4c(%rbp),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
ucomisd -0x80(%rbp),%xmm0
jbe    1778 <eplb+0x658>
movsd  -0x78(%rbp),%xmm0
movsd  -0xd8(%rbp),%xmm1
ff
cvtsi2sdl -0x4c(%rbp),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    177d <eplb+0x65d>
movsd  -0x78(%rbp),%xmm0
movsd  -0xd8(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm2
subsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm1
movsd  -0xd8(%rbp),%xmm2
ff
subsd  -0xd0(%rbp),%xmm2
ff
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0x182a(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     17f9 <eplb+0x6d9>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x1,-0x44(%rbp)
jmp    1fec <eplb+0xecc>
movsd  -0x80(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  0x17fa(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x58(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1ad7 <eplb+0x9b7>
jmp    186d <eplb+0x74d>
mov    -0x3c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x60(%rbp),%ecx
mov    %al,-0xf7(%rbp)
jg     18a3 <eplb+0x783>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
setae  %al
mov    %al,-0xf7(%rbp)
mov    -0xf7(%rbp),%al
test   $0x1,%al
jne    18b6 <eplb+0x796>
jmp    1902 <eplb+0x7e2>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x80(%rbp),%xmm0
jbe    18f4 <eplb+0x7d4>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    186d <eplb+0x74d>
jmp    1907 <eplb+0x7e7>
mov    -0x40(%rbp),%ecx
xor    %eax,%eax
cmp    -0x5c(%rbp),%ecx
mov    %al,-0xf8(%rbp)
jl     1939 <eplb+0x819>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x90(%rbp),%xmm0
ff
seta   %al
mov    %al,-0xf8(%rbp)
mov    -0xf8(%rbp),%al
test   $0x1,%al
jne    194c <eplb+0x82c>
jmp    19c6 <eplb+0x8a6>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jbe    1992 <eplb+0x872>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    19b8 <eplb+0x898>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1907 <eplb+0x7e7>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1ad2 <eplb+0x9b2>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jbe    1a18 <eplb+0x8f8>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1a3e <eplb+0x91e>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x80(%rbp),%xmm0
jbe    1a7c <eplb+0x95c>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    185c <eplb+0x73c>
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x4c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
movsd  -0xb8(%rbp),%xmm0
ff
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x58(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x50(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
movsd  -0xb8(%rbp),%xmm1
ff
cvtsi2sdl -0x58(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm1
ff
cvtsi2sdl -0x50(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm1
ff
cvtsi2sdl -0x54(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0x13ed(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1c29 <eplb+0xb09>
movl   $0x1,-0x44(%rbp)
jmp    1fec <eplb+0xecc>
movsd  -0xf0(%rbp),%xmm0
ff
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0x13be(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1c68 <eplb+0xb48>
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x1,-0x44(%rbp)
jmp    1fec <eplb+0xecc>
movsd  -0xe8(%rbp),%xmm0
ff
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0x137f(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1ca4 <eplb+0xb84>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x1,-0x44(%rbp)
jmp    1fec <eplb+0xecc>
xorps  %xmm0,%xmm0
ucomisd -0xe0(%rbp),%xmm0
ff
jbe    1e32 <eplb+0xd12>
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x50(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x54(%rbp),%eax
mov    %eax,-0x48(%rbp)
movsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x40(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1e1b <eplb+0xcfb>
jmp    1d35 <eplb+0xc15>
mov    -0x3c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x60(%rbp),%ecx
mov    %al,-0xf9(%rbp)
jg     1d68 <eplb+0xc48>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x80(%rbp),%xmm0
ucomisd %xmm1,%xmm0
setae  %al
mov    %al,-0xf9(%rbp)
mov    -0xf9(%rbp),%al
test   $0x1,%al
jne    1d7b <eplb+0xc5b>
jmp    1d89 <eplb+0xc69>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1d35 <eplb+0xc15>
jmp    1d8e <eplb+0xc6e>
mov    -0x40(%rbp),%ecx
xor    %eax,%eax
cmp    -0x5c(%rbp),%ecx
mov    %al,-0xfa(%rbp)
jl     1dbd <eplb+0xc9d>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x80(%rbp),%xmm0
seta   %al
mov    %al,-0xfa(%rbp)
mov    -0xfa(%rbp),%al
test   $0x1,%al
jne    1dd0 <eplb+0xcb0>
jmp    1dde <eplb+0xcbe>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1d8e <eplb+0xc6e>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1e16 <eplb+0xcf6>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1d24 <eplb+0xc04>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
sub    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1fb3 <eplb+0xe93>
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x50(%rbp),%eax
mov    %eax,-0x48(%rbp)
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x58(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x3c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1fa1 <eplb+0xe81>
jmp    1eb5 <eplb+0xd95>
mov    -0x3c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x60(%rbp),%ecx
mov    %al,-0xfb(%rbp)
jg     1eeb <eplb+0xdcb>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
setae  %al
mov    %al,-0xfb(%rbp)
mov    -0xfb(%rbp),%al
test   $0x1,%al
jne    1efe <eplb+0xdde>
jmp    1f0c <eplb+0xdec>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1eb5 <eplb+0xd95>
jmp    1f11 <eplb+0xdf1>
mov    -0x40(%rbp),%ecx
xor    %eax,%eax
cmp    -0x5c(%rbp),%ecx
mov    %al,-0xfc(%rbp)
jl     1f43 <eplb+0xe23>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
seta   %al
mov    %al,-0xfc(%rbp)
mov    -0xfc(%rbp),%al
test   $0x1,%al
jne    1f56 <eplb+0xe36>
jmp    1f64 <eplb+0xe44>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1f11 <eplb+0xdf1>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1f9c <eplb+0xe7c>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1ea4 <eplb+0xd84>
mov    -0x40(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
sub    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
cmpl   $0x0,-0x64(%rbp)
jne    1fe7 <eplb+0xec7>
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0x30(%rbp),%xmm0
cvtsi2sdl -0x50(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x1,-0x44(%rbp)
jmp    1fec <eplb+0xecc>
jmp    16e6 <eplb+0x5c6>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    20c6 <eplb+0xfa6>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x90(%rbp),%xmm0
ff
jbe    2041 <eplb+0xf21>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    20b3 <eplb+0xf93>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    209e <eplb+0xf7e>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x90(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    20ae <eplb+0xf8e>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    20b3 <eplb+0xf93>
jmp    20b8 <eplb+0xf98>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1ff3 <eplb+0xed3>
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0xf4(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<eplb>:
xorpd  %xmm4,%xmm4
ucomisd %xmm0,%xmm4
jbe    1136 <eplb+0x16>
lea    0xef7(%rip),%rdi
jmp    1030 <printf@plt>
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
movapd %xmm0,%xmm2
mov    %r8d,%ebp
mov    %rcx,%r13
mov    %rdi,%rbx
movsd  (%rcx),%xmm0
ucomisd %xmm4,%xmm0
movapd %xmm2,0x40(%rsp)
movapd %xmm1,0x30(%rsp)
mov    %rdx,0x70(%rsp)
mov    %rsi,0x68(%rsp)
jne    1176 <eplb+0x56>
jnp    1194 <eplb+0x74>
call   1040 <fabs@plt>
movapd 0x40(%rsp),%xmm2
xorps  %xmm4,%xmm4
cvtsi2sd %eax,%xmm4
movsd  %xmm4,(%rbx)
mov    $0x1,%r12d
jmp    1197 <eplb+0x77>
xor    %r12d,%r12d
cmp    $0x2,%ebp
mov    %ebp,(%rsp)
jl     1227 <eplb+0x107>
mov    %ebp,%r15d
mov    $0x1,%ebp
movapd %xmm4,%xmm5
mov    %r12d,%r14d
movapd 0x30(%rsp),%xmm3
jmp    11c9 <eplb+0xa9>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    %rbp,%r15
je     1234 <eplb+0x114>
movsd  0x0(%r13,%rbp,8),%xmm0
ucomisd 0xe48(%rip),%xmm0
jne    11dc <eplb+0xbc>
jnp    11c0 <eplb+0xa0>
movsd  %xmm4,0x10(%rsp)
movsd  %xmm5,0x8(%rsp)
call   1040 <fabs@plt>
movsd  0x8(%rsp),%xmm5
movapd 0x30(%rsp),%xmm3
movapd 0x40(%rsp),%xmm2
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movslq %r12d,%r12
movsd  %xmm0,(%rbx,%r12,8)
addsd  %xmm0,%xmm5
add    $0x1,%r14d
maxsd  0x10(%rsp),%xmm0
add    $0x1,%r12d
movapd %xmm0,%xmm4
jmp    11c0 <eplb+0xa0>
mov    %r12d,%r14d
movapd %xmm4,%xmm5
movapd 0x30(%rsp),%xmm3
ucomisd %xmm5,%xmm2
jae    132a <eplb+0x20a>
mov    %r12d,%eax
subsd  %xmm2,%xmm5
movapd 0xdb3(%rip),%xmm7
xorpd  %xmm2,%xmm7
lea    -0x1(%rax),%r15d
xor    %r12d,%r12d
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm3
jbe    13e1 <eplb+0x2c1>
ucomisd %xmm3,%xmm4
jbe    13e1 <eplb+0x2c1>
movapd %xmm7,0x80(%rsp)
movsd  %xmm5,0x8(%rsp)
xorpd  %xmm5,%xmm5
xorpd  %xmm6,%xmm6
mov    %r15d,%ebp
mov    $0x0,%esi
test   %eax,%eax
jle    13f2 <eplb+0x2d2>
xorpd  %xmm6,%xmm6
xor    %esi,%esi
mov    %r15d,%ebp
jmp    12b8 <eplb+0x198>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %ebp,%esi
jg     13f2 <eplb+0x2d2>
cmp    %eax,%esi
jge    12d2 <eplb+0x1b2>
movslq %esi,%rsi
nop
ucomisd (%rbx,%rsi,8),%xmm3
jb     12d2 <eplb+0x1b2>
add    $0x1,%rsi
cmp    %rsi,%rax
jne    12c0 <eplb+0x1a0>
mov    %eax,%esi
test   %ebp,%ebp
js     1300 <eplb+0x1e0>
mov    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rbp,8),%xmm0
ucomisd %xmm3,%xmm0
jbe    1300 <eplb+0x1e0>
addsd  %xmm0,%xmm6
lea    -0x1(%rbp),%rcx
test   %rbp,%rbp
mov    %rcx,%rbp
jg     12e0 <eplb+0x1c0>
mov    $0xffffffff,%ebp
cmp    %ebp,%esi
jge    12b0 <eplb+0x190>
movslq %esi,%rcx
movsd  (%rbx,%rcx,8),%xmm0
addsd  %xmm0,%xmm6
movslq %ebp,%rdx
movsd  (%rbx,%rdx,8),%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
movsd  %xmm0,(%rbx,%rdx,8)
add    $0x1,%esi
add    $0xffffffff,%ebp
jmp    12b0 <eplb+0x190>
mov    (%rsp),%ecx
test   %ecx,%ecx
jle    1cd8 <eplb+0xbb8>
mov    %ecx,%eax
cmp    $0x4,%ecx
jb     135d <eplb+0x23d>
lea    0x0(,%rax,8),%rcx
add    %r13,%rcx
cmp    %rbx,%rcx
jbe    1ab1 <eplb+0x991>
lea    (%rbx,%rax,8),%rcx
cmp    %r13,%rcx
jbe    1ab1 <eplb+0x991>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     1396 <eplb+0x276>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1380 <eplb+0x260>
cmp    $0x3,%rdx
jb     1cd8 <eplb+0xbb8>
movsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
movsd  0x8(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rcx,8)
movsd  0x10(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rcx,8)
movsd  0x18(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    13a0 <eplb+0x280>
jmp    1cd8 <eplb+0xbb8>
xorpd  %xmm1,%xmm1
xorpd  %xmm6,%xmm6
xor    %ecx,%ecx
xor    %edx,%edx
jmp    148a <eplb+0x36a>
mov    %rsi,0x60(%rsp)
movsd  %xmm4,0x10(%rsp)
mov    %r15d,%eax
sub    %ebp,%eax
mov    %eax,0x4(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  %xmm5,%xmm6
movsd  %xmm6,0x20(%rsp)
movsd  %xmm0,0x18(%rsp)
mulsd  %xmm3,%xmm0
subsd  %xmm0,%xmm6
subsd  %xmm2,%xmm6
movsd  %xmm6,0x28(%rsp)
movapd %xmm6,%xmm0
call   1040 <fabs@plt>
movsd  0x28(%rsp),%xmm5
xorpd  %xmm6,%xmm6
ucomisd %xmm5,%xmm6
jbe    1a5b <eplb+0x93b>
xor    %ecx,%ecx
mov    %ebp,%r15d
movapd 0x30(%rsp),%xmm3
movapd %xmm3,%xmm4
movsd  0x20(%rsp),%xmm2
movapd %xmm2,%xmm1
movapd %xmm5,%xmm7
movapd 0x40(%rsp),%xmm0
movsd  0x8(%rsp),%xmm5
mov    0x4(%rsp),%edx
cmp    $0xffffffff,%ebp
je     1a9e <eplb+0x97e>
test   %eax,%eax
jle    1b27 <eplb+0xa07>
mov    %r13,0x58(%rsp)
jmp    14f8 <eplb+0x3d8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ebp,%r15d
movapd 0x40(%rsp),%xmm8
movsd  0x10(%rsp),%xmm4
movsd  0x28(%rsp),%xmm1
movsd  0x20(%rsp),%xmm3
movsd  0x50(%rsp),%xmm2
movsd  0x78(%rsp),%xmm6
mov    %r15d,%eax
sub    %r13d,%eax
mov    0x4(%rsp),%r14d
mov    %r12d,%edx
movapd %xmm7,%xmm5
movapd %xmm6,%xmm7
mov    0x18(%rsp),%r12d
movapd %xmm2,%xmm6
mov    %r13d,%ecx
cmp    $0xffffffff,%eax
mov    0x58(%rsp),%r13
je     1b01 <eplb+0x9e1>
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
movapd %xmm5,%xmm2
divsd  %xmm0,%xmm2
addsd  %xmm6,%xmm2
test   %edx,%edx
movsd  %xmm1,0x28(%rsp)
mov    %edx,0x4(%rsp)
mov    %rcx,%rbp
je     1540 <eplb+0x420>
xorps  %xmm1,%xmm1
cvtsi2sd %edx,%xmm1
movapd %xmm7,%xmm0
divsd  %xmm1,%xmm0
addsd  %xmm4,%xmm0
ucomisd %xmm2,%xmm0
mov    (%rsp),%r14d
jbe    1544 <eplb+0x424>
movapd %xmm0,%xmm2
jmp    1544 <eplb+0x424>
mov    (%rsp),%r14d
movapd %xmm2,0x30(%rsp)
add    $0x1,%r12d
movapd %xmm4,%xmm0
subsd  %xmm6,%xmm0
mulsd  %xmm7,%xmm0
subsd  %xmm5,%xmm7
divsd  %xmm7,%xmm0
subsd  %xmm0,%xmm4
movsd  %xmm4,0x10(%rsp)
movapd %xmm2,%xmm0
subsd  %xmm4,%xmm0
call   1040 <fabs@plt>
test   %eax,%eax
jle    1adb <eplb+0x9bb>
movsd  0x10(%rsp),%xmm1
movapd %xmm1,%xmm6
movapd 0x30(%rsp),%xmm0
addsd  %xmm0,%xmm6
mulsd  0xa73(%rip),%xmm6
mov    %r15,%r10
mov    %rbp,%r11
cmp    %r10d,%r11d
mov    %r12d,0x18(%rsp)
jle    1720 <eplb+0x600>
xorpd  %xmm5,%xmm5
xor    %r8d,%r8d
xor    %r14d,%r14d
xor    %r12d,%r12d
xorpd  %xmm7,%xmm7
xorpd  %xmm0,%xmm0
mov    %r10d,%r15d
mov    %r11d,%r13d
movapd 0x40(%rsp),%xmm8
movsd  0x28(%rsp),%xmm9
mov    %r11,0x60(%rsp)
mov    %r10,%rbp
movsd  %xmm7,0x8(%rsp)
addsd  %xmm0,%xmm9
movsd  %xmm9,0x28(%rsp)
add    0x4(%rsp),%r12d
add    %r12d,%r8d
mov    %r8d,0x4(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %r8d,%xmm0
addsd  %xmm9,%xmm5
movsd  %xmm0,0x90(%rsp)
movsd  %xmm6,0x50(%rsp)
mulsd  %xmm6,%xmm0
movsd  %xmm5,0x20(%rsp)
subsd  %xmm0,%xmm5
subsd  %xmm8,%xmm5
movapd %xmm5,0x80(%rsp)
movapd %xmm5,%xmm0
call   1040 <fabs@plt>
test   %eax,%eax
jle    1ae3 <eplb+0x9c3>
xorps  %xmm1,%xmm1
cvtsi2sd %r12d,%xmm1
mulsd  0x10(%rsp),%xmm1
movsd  0x28(%rsp),%xmm0
subsd  %xmm1,%xmm0
subsd  0x40(%rsp),%xmm0
movsd  %xmm0,0x78(%rsp)
call   1040 <fabs@plt>
test   %eax,%eax
jle    1aeb <eplb+0x9cb>
add    0x4(%rsp),%r14d
xorps  %xmm1,%xmm1
cvtsi2sd %r14d,%xmm1
movsd  0x8(%rsp),%xmm0
addsd  0x20(%rsp),%xmm0
mulsd  0x30(%rsp),%xmm1
subsd  %xmm1,%xmm0
subsd  0x40(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
call   1040 <fabs@plt>
test   %eax,%eax
jle    1b11 <eplb+0x9f1>
xorpd  %xmm0,%xmm0
movapd 0x80(%rsp),%xmm7
ucomisd %xmm7,%xmm0
jbe    18b0 <eplb+0x790>
mov    0x60(%rsp),%rcx
cmp    %r15d,%ecx
jle    1990 <eplb+0x870>
mov    %ecx,%r13d
mov    0x18(%rsp),%r12d
movapd 0x40(%rsp),%xmm8
movapd 0x30(%rsp),%xmm2
movsd  0x8(%rsp),%xmm5
movsd  0x20(%rsp),%xmm3
movsd  0x50(%rsp),%xmm4
mov    %r15d,%eax
sub    %r13d,%eax
movapd %xmm3,%xmm1
mov    0x4(%rsp),%edx
jmp    14e3 <eplb+0x3c3>
cs nopw 0x0(%rax,%rax,1)
movapd %xmm0,%xmm10
movapd %xmm1,%xmm11
movslq %r10d,%rbp
lea    0x1(%r10),%eax
mov    %eax,0x8(%rsp)
movslq %r11d,%rdx
lea    -0x1(%r11),%r9d
xor    %r12d,%r12d
xorpd  %xmm0,%xmm0
mov    %r11d,%r13d
mov    %r10d,%r15d
xorpd  %xmm7,%xmm7
xorpd  %xmm5,%xmm5
xor    %r14d,%r14d
xor    %r8d,%r8d
movapd 0x40(%rsp),%xmm8
movsd  0x8b2(%rip),%xmm4
movsd  0x28(%rsp),%xmm9
jmp    1795 <eplb+0x675>
nop
mov    %al,%sil
add    %esi,%r14d
addsd  %xmm3,%xmm7
movsd  %xmm2,(%rbx,%rdi,8)
movsd  %xmm1,(%rbx,%rcx,8)
add    $0x1,%r13d
add    $0xffffffff,%r15d
cmp    %r15d,%r13d
jg     15da <eplb+0x4ba>
cmp    %r10d,%r13d
jg     17f7 <eplb+0x6d7>
movslq %r13d,%rdi
add    $0xffffffffffffffff,%rdi
jmp    17c6 <eplb+0x6a6>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %al,%cl
add    %ecx,%r14d
addsd  %xmm1,%xmm7
add    $0x1,%r13d
add    $0x1,%rdi
cmp    %rbp,%rdi
jge    17f0 <eplb+0x6d0>
movsd  0x8(%rbx,%rdi,8),%xmm1
ucomisd %xmm1,%xmm6
jb     17f7 <eplb+0x6d7>
xor    %ecx,%ecx
ucomisd %xmm10,%xmm1
seta   %al
ja     17b0 <eplb+0x690>
movapd %xmm4,%xmm1
jmp    17b0 <eplb+0x690>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x8(%rsp),%eax
mov    %eax,%r13d
cmp    %r11d,%r15d
jl     1853 <eplb+0x733>
movslq %r15d,%rdi
add    $0x1,%rdi
jmp    1825 <eplb+0x705>
cs nopw 0x0(%rax,%rax,1)
nop
addsd  %xmm1,%xmm5
add    $0x1,%r8d
add    $0xffffffff,%r15d
add    $0xffffffffffffffff,%rdi
cmp    %rdx,%rdi
jle    1850 <eplb+0x730>
movsd  -0x8(%rbx,%rdi,8),%xmm1
ucomisd %xmm6,%xmm1
jbe    1853 <eplb+0x733>
ucomisd %xmm11,%xmm1
jbe    1810 <eplb+0x6f0>
addsd  %xmm1,%xmm0
add    $0x1,%r12d
jmp    1818 <eplb+0x6f8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r9d,%r15d
cmp    %r15d,%r13d
jge    178c <eplb+0x66c>
movslq %r13d,%rdi
movsd  (%rbx,%rdi,8),%xmm1
ucomisd %xmm11,%xmm1
jbe    1880 <eplb+0x760>
addsd  %xmm1,%xmm0
add    $0x1,%r12d
jmp    1888 <eplb+0x768>
cs nopw 0x0(%rax,%rax,1)
nop
addsd  %xmm1,%xmm5
add    $0x1,%r8d
movslq %r15d,%rcx
movsd  (%rbx,%rcx,8),%xmm2
xor    %esi,%esi
ucomisd %xmm10,%xmm2
seta   %al
movapd %xmm2,%xmm3
ja     1770 <eplb+0x650>
movapd %xmm4,%xmm3
jmp    1770 <eplb+0x650>
nopl   (%rax)
cmp    %ebp,%r13d
jg     14a0 <eplb+0x380>
movslq %ebp,%rax
lea    0x1(%rbp),%r8d
movslq %r13d,%rdx
lea    -0x1(%r13),%esi
mov    %r13d,%edi
mov    %ebp,%r15d
movapd 0x40(%rsp),%xmm8
movsd  0x10(%rsp),%xmm4
movsd  0x28(%rsp),%xmm1
movsd  0x20(%rsp),%xmm3
movsd  0x50(%rsp),%xmm2
movsd  0x78(%rsp),%xmm6
jmp    1909 <eplb+0x7e9>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %r15d,%edi
jg     14c8 <eplb+0x3a8>
cmp    %ebp,%edi
jg     1937 <eplb+0x817>
movslq %edi,%rcx
add    $0xffffffffffffffff,%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
ucomisd 0x8(%rbx,%rcx,8),%xmm4
jb     1937 <eplb+0x817>
add    $0x1,%edi
add    $0x1,%rcx
cmp    %rax,%rcx
jl     1920 <eplb+0x800>
mov    %r8d,%edi
cmp    %r13d,%r15d
jl     196c <eplb+0x84c>
movslq %r15d,%rcx
add    $0x1,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%rbx,%rcx,8),%xmm0
ucomisd %xmm4,%xmm0
jbe    196c <eplb+0x84c>
add    $0xffffffff,%r15d
add    $0xffffffffffffffff,%rcx
cmp    %rdx,%rcx
jg     1950 <eplb+0x830>
mov    %esi,%r15d
cmp    %r15d,%edi
jge    1900 <eplb+0x7e0>
movslq %r15d,%rcx
movsd  (%rbx,%rcx,8),%xmm0
movslq %edi,%rcx
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%edi
add    $0xffffffff,%r15d
jmp    1900 <eplb+0x7e0>
nopl   (%rax)
movslq %r15d,%rax
lea    0x1(%r15),%r8d
movslq %ecx,%rdx
lea    -0x1(%rcx),%esi
mov    %ecx,%r13d
mov    %r15d,%edi
mov    0x18(%rsp),%r12d
movapd 0x40(%rsp),%xmm8
movapd 0x30(%rsp),%xmm2
movsd  0x8(%rsp),%xmm5
movsd  0x20(%rsp),%xmm3
movsd  0x50(%rsp),%xmm4
jmp    19d9 <eplb+0x8b9>
nopl   0x0(%rax)
cmp    %edi,%r13d
jg     1703 <eplb+0x5e3>
cmp    %r15d,%r13d
jg     1a08 <eplb+0x8e8>
movslq %r13d,%rbp
add    $0xffffffffffffffff,%rbp
cs nopw 0x0(%rax,%rax,1)
nop
ucomisd 0x8(%rbx,%rbp,8),%xmm2
jb     1a08 <eplb+0x8e8>
add    $0x1,%r13d
add    $0x1,%rbp
cmp    %rax,%rbp
jl     19f0 <eplb+0x8d0>
mov    %r8d,%r13d
cmp    %ecx,%edi
jl     1a3a <eplb+0x91a>
movslq %edi,%rbp
add    $0x1,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%rbx,%rbp,8),%xmm0
ucomisd %xmm2,%xmm0
jbe    1a3a <eplb+0x91a>
add    $0xffffffff,%edi
add    $0xffffffffffffffff,%rbp
cmp    %rdx,%rbp
jg     1a20 <eplb+0x900>
mov    %esi,%edi
cmp    %edi,%r13d
jge    19d0 <eplb+0x8b0>
movslq %r13d,%rbp
movsd  (%rbx,%rbp,8),%xmm0
movslq %edi,%rbp
movsd  %xmm0,(%rbx,%rbp,8)
add    $0x1,%r13d
add    $0xffffffff,%edi
jmp    19d0 <eplb+0x8b0>
mov    %r15d,%ebp
mov    0x60(%rsp),%rcx
sub    %ecx,%ebp
xorpd  %xmm1,%xmm1
mov    0x4(%rsp),%r14d
xor    %edx,%edx
movapd 0x30(%rsp),%xmm3
movapd %xmm3,%xmm6
movapd 0x40(%rsp),%xmm0
movsd  0x10(%rsp),%xmm4
movapd 0x80(%rsp),%xmm7
movsd  0x20(%rsp),%xmm2
cmp    $0xffffffff,%ebp
jne    1482 <eplb+0x362>
subsd  %xmm0,%xmm2
divsd  0x18(%rsp),%xmm2
xor    %r12d,%r12d
movapd %xmm2,%xmm3
jmp    1b2a <eplb+0xa0a>
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    1c11 <eplb+0xaf1>
xor    %edi,%edi
jmp    1c85 <eplb+0xb65>
movapd 0x30(%rsp),%xmm3
jmp    1b2e <eplb+0xa0e>
movsd  0x50(%rsp),%xmm3
jmp    1af1 <eplb+0x9d1>
movsd  0x10(%rsp),%xmm3
mov    0x58(%rsp),%r13
mov    (%rsp),%r14d
mov    0x18(%rsp),%r12d
jmp    1b2e <eplb+0xa0e>
subsd  %xmm8,%xmm3
divsd  0x90(%rsp),%xmm3
jmp    1b2a <eplb+0xa0a>
mov    0x58(%rsp),%r13
mov    (%rsp),%r14d
mov    0x18(%rsp),%r12d
movapd 0x30(%rsp),%xmm3
jmp    1b2e <eplb+0xa0e>
xor    %r12d,%r12d
mov    (%rsp),%r14d
test   %r14d,%r14d
jle    1bfb <eplb+0xadb>
movapd 0x4c1(%rip),%xmm0
xorpd  %xmm3,%xmm0
mov    %r14d,%ecx
cmp    $0x1,%r14d
jne    1b71 <eplb+0xa51>
xor    %eax,%eax
test   $0x1,%cl
je     1bfb <eplb+0xadb>
movsd  0x0(%r13,%rax,8),%xmm1
ucomisd %xmm3,%xmm1
jbe    1be4 <eplb+0xac4>
subsd  %xmm3,%xmm1
jmp    1bf2 <eplb+0xad2>
mov    %ecx,%edx
and    $0xfffffffe,%edx
xor    %eax,%eax
jmp    1b97 <eplb+0xa77>
nopw   0x0(%rax,%rax,1)
subsd  %xmm3,%xmm1
movapd %xmm1,%xmm2
movsd  %xmm2,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
je     1b4e <eplb+0xa2e>
movsd  0x0(%r13,%rax,8),%xmm1
ucomisd %xmm3,%xmm1
jbe    1bb0 <eplb+0xa90>
subsd  %xmm3,%xmm1
jmp    1bbe <eplb+0xa9e>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm2,%xmm2
ucomisd %xmm1,%xmm0
jbe    1bc2 <eplb+0xaa2>
addsd  %xmm3,%xmm1
movapd %xmm1,%xmm2
movsd  %xmm2,(%rbx,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm1
ucomisd %xmm3,%xmm1
ja     1b80 <eplb+0xa60>
xorpd  %xmm2,%xmm2
ucomisd %xmm1,%xmm0
jbe    1b88 <eplb+0xa68>
addsd  %xmm3,%xmm1
jmp    1b84 <eplb+0xa64>
xorpd  %xmm2,%xmm2
ucomisd %xmm1,%xmm0
jbe    1bf6 <eplb+0xad6>
addsd  %xmm3,%xmm1
movapd %xmm1,%xmm2
movsd  %xmm2,(%rbx,%rax,8)
mov    0x68(%rsp),%rax
movsd  %xmm3,(%rax)
mov    0x70(%rsp),%rax
mov    %r12d,(%rax)
jmp    1cef <eplb+0xbcf>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups 0x0(%r13,%rdi,8),%xmm0
movups 0x10(%r13,%rdi,8),%xmm1
movups %xmm0,(%rbx,%rdi,8)
movups %xmm1,0x10(%rbx,%rdi,8)
movups 0x20(%r13,%rdi,8),%xmm0
movups 0x30(%r13,%rdi,8),%xmm1
movups %xmm0,0x20(%rbx,%rdi,8)
movups %xmm1,0x30(%rbx,%rdi,8)
movups 0x40(%r13,%rdi,8),%xmm0
movups 0x50(%r13,%rdi,8),%xmm1
movups %xmm0,0x40(%rbx,%rdi,8)
movups %xmm1,0x50(%rbx,%rdi,8)
movupd 0x60(%r13,%rdi,8),%xmm0
movupd 0x70(%r13,%rdi,8),%xmm1
movupd %xmm0,0x60(%rbx,%rdi,8)
movupd %xmm1,0x70(%rbx,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1c20 <eplb+0xb00>
test   %rdx,%rdx
je     1ccf <eplb+0xbaf>
lea    (%rbx,%rdi,8),%rsi
add    $0x10,%rsi
lea    0x10(,%rdi,8),%rdi
add    %r13,%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    1cb0 <eplb+0xb90>
cmp    %rax,%rcx
jne    135f <eplb+0x23f>
mov    0x68(%rsp),%rax
movq   $0x0,(%rax)
mov    0x70(%rsp),%rax
movl   $0x0,(%rax)
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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