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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ exit(int);
int fabs(double);
int /*<<< orphan*/ printf(char *);
void epsp(double *x, double *root, int *stepsp, 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!");
    exit(-1);
  }
  v_max = v[0];
  for (i = 1; i < n; i++) {
    if (v[i] > v_max)
      v_max = v[i];
  }
  lambda_1 = v_max - z;
  lambda_2 = v_max;
  V_i = 0;
  s_1 = 0;
  rho_1 = 0;
  for (i = 0; i < n; i++) {
    if (v[i] > lambda_1) {
      x[V_i] = v[i];
      s_1 += x[V_i];
      rho_1++;
      V_i++;
    }
  }
  f_lambda_1 = s_1 - rho_1 * lambda_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-12) {
      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-12) {
      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-12) {
      flag = 1;
      break;
    }
    if (fabs(f_lambda_S) < 1e-12) {
      lambda = lambda_S;
      flag = 1;
      break;
    }
    if (fabs(f_lambda_T) < 1e-12) {
      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
      x[i] = 0;
  }
  *root = lambda;
  *stepsp = iter_step;
}


x86 assembly (clang, -O0):
<epsp>:
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    118e <epsp+0x5e>
lea    0x1e91(%rip),%rdi
call   1030 <printf@plt>
mov    $0xffffffff,%edi
call   1050 <exit@plt>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11f4 <epsp+0xc4>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0xc0(%rbp),%xmm0
ff
jbe    11e1 <epsp+0xb1>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    11e6 <epsp+0xb6>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11a5 <epsp+0x75>
movsd  -0xc0(%rbp),%xmm0
ff
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12b3 <epsp+0x183>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    12a0 <epsp+0x170>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%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    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    12a5 <epsp+0x175>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1233 <epsp+0x103>
movsd  -0x98(%rbp),%xmm1
ff
cvtsi2sdl -0x48(%rbp),%xmm0
movsd  -0x70(%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,-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    1656 <epsp+0x526>
movsd  -0x90(%rbp),%xmm0
ff
ucomisd -0x70(%rbp),%xmm0
jbe    1656 <epsp+0x526>
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     14ed <epsp+0x3bd>
jmp    139d <epsp+0x26d>
mov    -0x3c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x60(%rbp),%ecx
mov    %al,-0xf5(%rbp)
jg     13d3 <epsp+0x2a3>
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    13e6 <epsp+0x2b6>
jmp    13f4 <epsp+0x2c4>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    139d <epsp+0x26d>
jmp    13f9 <epsp+0x2c9>
mov    -0x40(%rbp),%ecx
xor    %eax,%eax
cmp    -0x5c(%rbp),%ecx
mov    %al,-0xf6(%rbp)
jl     142b <epsp+0x2fb>
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    143e <epsp+0x30e>
jmp    1469 <epsp+0x339>
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    13f9 <epsp+0x2c9>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    14e8 <epsp+0x3b8>
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    138c <epsp+0x25c>
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  0x1a8f(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1582 <epsp+0x452>
movl   $0x1,-0x44(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0xe0(%rbp),%xmm0
ff
jbe    15dd <epsp+0x4ad>
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    1622 <epsp+0x4f2>
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    1651 <epsp+0x521>
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    1656 <epsp+0x526>
jmp    165b <epsp+0x52b>
cmpl   $0x0,-0x44(%rbp)
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    1671 <epsp+0x541>
jmp    1f61 <epsp+0xe31>
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     16f2 <epsp+0x5c2>
movsd  -0x78(%rbp),%xmm0
movsd  -0xd8(%rbp),%xmm1
ff
cvtsi2sdl -0x4c(%rbp),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
ucomisd -0x80(%rbp),%xmm0
jbe    16ed <epsp+0x5bd>
movsd  -0x78(%rbp),%xmm0
movsd  -0xd8(%rbp),%xmm1
ff
cvtsi2sdl -0x4c(%rbp),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    16f2 <epsp+0x5c2>
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  0x18b5(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     176e <epsp+0x63e>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x1,-0x44(%rbp)
jmp    1f61 <epsp+0xe31>
movsd  -0x80(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  0x1885(%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     1a4c <epsp+0x91c>
jmp    17e2 <epsp+0x6b2>
mov    -0x3c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x60(%rbp),%ecx
mov    %al,-0xf7(%rbp)
jg     1818 <epsp+0x6e8>
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    182b <epsp+0x6fb>
jmp    1877 <epsp+0x747>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x80(%rbp),%xmm0
jbe    1869 <epsp+0x739>
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    17e2 <epsp+0x6b2>
jmp    187c <epsp+0x74c>
mov    -0x40(%rbp),%ecx
xor    %eax,%eax
cmp    -0x5c(%rbp),%ecx
mov    %al,-0xf8(%rbp)
jl     18ae <epsp+0x77e>
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    18c1 <epsp+0x791>
jmp    193b <epsp+0x80b>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jbe    1907 <epsp+0x7d7>
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    192d <epsp+0x7fd>
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    187c <epsp+0x74c>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1a47 <epsp+0x917>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jbe    198d <epsp+0x85d>
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    19b3 <epsp+0x883>
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    19f1 <epsp+0x8c1>
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    17d1 <epsp+0x6a1>
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  0x1478(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1b9e <epsp+0xa6e>
movl   $0x1,-0x44(%rbp)
jmp    1f61 <epsp+0xe31>
movsd  -0xf0(%rbp),%xmm0
ff
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0x1449(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1bdd <epsp+0xaad>
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x1,-0x44(%rbp)
jmp    1f61 <epsp+0xe31>
movsd  -0xe8(%rbp),%xmm0
ff
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0x140a(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1c19 <epsp+0xae9>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x1,-0x44(%rbp)
jmp    1f61 <epsp+0xe31>
xorps  %xmm0,%xmm0
ucomisd -0xe0(%rbp),%xmm0
ff
jbe    1da7 <epsp+0xc77>
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     1d90 <epsp+0xc60>
jmp    1caa <epsp+0xb7a>
mov    -0x3c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x60(%rbp),%ecx
mov    %al,-0xf9(%rbp)
jg     1cdd <epsp+0xbad>
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    1cf0 <epsp+0xbc0>
jmp    1cfe <epsp+0xbce>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1caa <epsp+0xb7a>
jmp    1d03 <epsp+0xbd3>
mov    -0x40(%rbp),%ecx
xor    %eax,%eax
cmp    -0x5c(%rbp),%ecx
mov    %al,-0xfa(%rbp)
jl     1d32 <epsp+0xc02>
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    1d45 <epsp+0xc15>
jmp    1d53 <epsp+0xc23>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1d03 <epsp+0xbd3>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1d8b <epsp+0xc5b>
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    1c99 <epsp+0xb69>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
sub    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1f28 <epsp+0xdf8>
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     1f16 <epsp+0xde6>
jmp    1e2a <epsp+0xcfa>
mov    -0x3c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x60(%rbp),%ecx
mov    %al,-0xfb(%rbp)
jg     1e60 <epsp+0xd30>
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    1e73 <epsp+0xd43>
jmp    1e81 <epsp+0xd51>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1e2a <epsp+0xcfa>
jmp    1e86 <epsp+0xd56>
mov    -0x40(%rbp),%ecx
xor    %eax,%eax
cmp    -0x5c(%rbp),%ecx
mov    %al,-0xfc(%rbp)
jl     1eb8 <epsp+0xd88>
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    1ecb <epsp+0xd9b>
jmp    1ed9 <epsp+0xda9>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1e86 <epsp+0xd56>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1f11 <epsp+0xde1>
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    1e19 <epsp+0xce9>
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    1f5c <epsp+0xe2c>
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    1f61 <epsp+0xe31>
jmp    165b <epsp+0x52b>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1fd9 <epsp+0xea9>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x90(%rbp),%xmm0
ff
jbe    1fb6 <epsp+0xe86>
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    1fc6 <epsp+0xe96>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1fcb <epsp+0xe9b>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1f68 <epsp+0xe38>
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):
<epsp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %rdx,0xa8(%rsp)
mov    %rsi,0xa0(%rsp)
xorpd  %xmm2,%xmm2
ucomisd %xmm0,%xmm2
ja     1c39 <epsp+0xb09>
mov    %rcx,%r14
mov    %rdi,%rbx
movsd  (%rcx),%xmm4
mov    %r8d,%r15d
movapd %xmm4,%xmm6
mov    %r8d,0x4c(%rsp)
cmp    $0x2,%r8d
jl     1216 <epsp+0xe6>
lea    -0x1(%r15),%rdx
lea    -0x2(%r15),%rcx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    119d <epsp+0x6d>
mov    $0x1,%ecx
movapd %xmm4,%xmm3
jmp    11e9 <epsp+0xb9>
and    $0xfffffffffffffffc,%rdx
xor    %ecx,%ecx
movapd %xmm4,%xmm3
nopw   0x0(%rax,%rax,1)
movsd  0x8(%r14,%rcx,8),%xmm2
maxsd  %xmm3,%xmm2
movsd  0x10(%r14,%rcx,8),%xmm3
maxsd  %xmm2,%xmm3
movsd  0x18(%r14,%rcx,8),%xmm2
maxsd  %xmm3,%xmm2
movsd  0x20(%r14,%rcx,8),%xmm3
maxsd  %xmm2,%xmm3
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    11b0 <epsp+0x80>
add    $0x1,%rcx
movapd %xmm3,%xmm6
test   %rax,%rax
je     1216 <epsp+0xe6>
lea    (%r14,%rcx,8),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rdx,8),%xmm6
maxsd  %xmm3,%xmm6
add    $0x1,%rdx
movapd %xmm6,%xmm3
cmp    %rdx,%rax
jne    1200 <epsp+0xd0>
movapd %xmm6,%xmm7
subsd  %xmm0,%xmm7
xorpd  %xmm8,%xmm8
xor    %edx,%edx
mov    $0x0,%r13d
mov    $0x0,%eax
xorpd  %xmm3,%xmm3
cmpl   $0x0,0x4c(%rsp)
jle    1287 <epsp+0x157>
xor    %eax,%eax
xorpd  %xmm3,%xmm3
mov    $0x1,%ecx
xor    %r13d,%r13d
ucomisd %xmm7,%xmm4
jbe    1282 <epsp+0x152>
jmp    1270 <epsp+0x140>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rcx,8),%xmm4
add    $0x1,%rcx
ucomisd %xmm7,%xmm4
jbe    1282 <epsp+0x152>
cltq
movsd  %xmm4,(%rbx,%rax,8)
addsd  %xmm4,%xmm3
add    $0x1,%r13d
add    $0x1,%eax
cmp    %rcx,%r15
jne    1260 <epsp+0x130>
xorps  %xmm2,%xmm2
cvtsi2sd %r13d,%xmm2
mulsd  %xmm7,%xmm2
subsd  %xmm2,%xmm3
subsd  %xmm0,%xmm3
movapd 0xd5d(%rip),%xmm4
xorpd  %xmm0,%xmm4
lea    -0x1(%rax),%ecx
ucomisd %xmm1,%xmm6
movapd %xmm0,0x70(%rsp)
jbe    137a <epsp+0x24a>
ucomisd %xmm7,%xmm1
jbe    137a <epsp+0x24a>
movapd %xmm4,0x90(%rsp)
movsd  %xmm3,0x30(%rsp)
movsd  %xmm6,0x18(%rsp)
mov    %eax,%eax
xorpd  %xmm5,%xmm5
xorpd  %xmm4,%xmm4
mov    %rcx,%rdi
mov    %ecx,%ebp
mov    $0x0,%esi
test   %eax,%eax
jle    1381 <epsp+0x251>
xorpd  %xmm4,%xmm4
xor    %esi,%esi
mov    %edi,%ebp
jmp    1304 <epsp+0x1d4>
nop
cmp    %ebp,%esi
jg     1381 <epsp+0x251>
cmp    %eax,%esi
jge    1322 <epsp+0x1f2>
movslq %esi,%rsi
nopl   0x0(%rax,%rax,1)
ucomisd (%rbx,%rsi,8),%xmm1
jb     1322 <epsp+0x1f2>
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1310 <epsp+0x1e0>
mov    %eax,%esi
test   %ebp,%ebp
js     1350 <epsp+0x220>
mov    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rbp,8),%xmm2
ucomisd %xmm1,%xmm2
jbe    1350 <epsp+0x220>
addsd  %xmm2,%xmm4
lea    -0x1(%rbp),%rcx
test   %rbp,%rbp
mov    %rcx,%rbp
jg     1330 <epsp+0x200>
mov    $0xffffffff,%ebp
cmp    %ebp,%esi
jge    1300 <epsp+0x1d0>
movslq %esi,%rcx
movsd  (%rbx,%rcx,8),%xmm3
addsd  %xmm3,%xmm4
movslq %ebp,%rdx
movsd  (%rbx,%rdx,8),%xmm2
movsd  %xmm2,(%rbx,%rcx,8)
movsd  %xmm3,(%rbx,%rdx,8)
add    $0x1,%esi
add    $0xffffffff,%ebp
jmp    1300 <epsp+0x1d0>
xor    %esi,%esi
jmp    1462 <epsp+0x332>
movsd  %xmm7,0x28(%rsp)
mov    %rsi,0x80(%rsp)
mov    %rdi,0x38(%rsp)
mov    %edi,%r12d
sub    %ebp,%r12d
xorps  %xmm2,%xmm2
cvtsi2sd %r12d,%xmm2
addsd  %xmm5,%xmm4
movsd  %xmm4,0x8(%rsp)
movsd  %xmm2,0x40(%rsp)
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm4
subsd  %xmm0,%xmm4
movsd  %xmm4,0x10(%rsp)
movapd %xmm4,%xmm0
movapd %xmm1,0x50(%rsp)
call   1040 <fabs@plt>
movsd  0x10(%rsp),%xmm3
xorpd  %xmm0,%xmm0
ucomisd %xmm3,%xmm0
jbe    1411 <epsp+0x2e1>
xor    %edx,%edx
mov    %ebp,%ecx
movapd 0x50(%rsp),%xmm5
movapd %xmm5,%xmm6
movsd  0x8(%rsp),%xmm1
movapd %xmm1,%xmm8
movapd %xmm3,%xmm4
movsd  0x30(%rsp),%xmm3
mov    %r12d,%esi
movsd  0x28(%rsp),%xmm7
jmp    144b <epsp+0x31b>
mov    0x38(%rsp),%rcx
mov    %ecx,%ebp
mov    0x80(%rsp),%rdx
sub    %edx,%ebp
xorpd  %xmm8,%xmm8
mov    %r12d,%r13d
xor    %esi,%esi
movapd 0x50(%rsp),%xmm5
movapd %xmm5,%xmm7
movsd  0x18(%rsp),%xmm6
movapd 0x90(%rsp),%xmm4
movsd  0x8(%rsp),%xmm1
cmp    $0xffffffff,%ebp
movapd 0x70(%rsp),%xmm0
je     19fc <epsp+0x8cc>
test   %eax,%eax
jle    1a59 <epsp+0x929>
xor    %ebp,%ebp
mov    %r14,0x20(%rsp)
mov    %r15,0x68(%rsp)
jmp    14bc <epsp+0x38c>
movsd  0x18(%rsp),%xmm6
movsd  0x10(%rsp),%xmm8
movsd  0x88(%rsp),%xmm7
mov    %ebp,%eax
sub    %r15d,%eax
mov    %r12d,%r13d
mov    %r14d,%r12d
movapd %xmm4,%xmm3
movapd %xmm7,%xmm4
mov    0x20(%rsp),%r14
movapd %xmm1,%xmm7
mov    %ebp,%ecx
mov    %r15d,%edx
mov    %r12d,%esi
cmp    $0xffffffff,%eax
mov    0x68(%rsp),%r15
mov    0x28(%rsp),%ebp
je     1a4a <epsp+0x91a>
mov    %rcx,0x38(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %r13d,%xmm0
movapd %xmm3,%xmm2
divsd  %xmm0,%xmm2
addsd  %xmm7,%xmm2
test   %esi,%esi
movsd  %xmm8,0x10(%rsp)
mov    %esi,0x8(%rsp)
mov    %rdx,%r12
je     1504 <epsp+0x3d4>
xorps  %xmm1,%xmm1
cvtsi2sd %esi,%xmm1
movapd %xmm4,%xmm0
divsd  %xmm1,%xmm0
addsd  %xmm6,%xmm0
ucomisd %xmm2,%xmm0
jbe    1504 <epsp+0x3d4>
movapd %xmm0,%xmm2
movapd %xmm2,0x50(%rsp)
add    $0x1,%ebp
movapd %xmm6,%xmm0
subsd  %xmm7,%xmm0
mulsd  %xmm4,%xmm0
subsd  %xmm3,%xmm4
divsd  %xmm4,%xmm0
subsd  %xmm0,%xmm6
movsd  %xmm6,0x18(%rsp)
movapd %xmm2,%xmm0
subsd  %xmm6,%xmm0
call   1040 <fabs@plt>
test   %eax,%eax
jle    1a0e <epsp+0x8de>
mov    %ebp,0x28(%rsp)
movsd  0x18(%rsp),%xmm1
movapd %xmm1,%xmm6
movapd 0x50(%rsp),%xmm0
addsd  %xmm0,%xmm6
mulsd  0xab0(%rip),%xmm6
mov    %r12,%r11
mov    0x38(%rsp),%rsi
cmp    %esi,%r11d
jle    16d0 <epsp+0x5a0>
xorpd  %xmm4,%xmm4
xor    %r12d,%r12d
xor    %r13d,%r13d
xor    %r14d,%r14d
xorpd  %xmm7,%xmm7
xorpd  %xmm0,%xmm0
mov    %esi,%ebp
mov    %r11d,%r15d
movapd 0x70(%rsp),%xmm8
movsd  0x10(%rsp),%xmm9
movsd  %xmm7,0x30(%rsp)
mov    %r11,0x80(%rsp)
addsd  %xmm0,%xmm9
movsd  %xmm9,0x10(%rsp)
add    0x8(%rsp),%r14d
add    %r14d,%r12d
xorps  %xmm0,%xmm0
cvtsi2sd %r12d,%xmm0
addsd  %xmm9,%xmm4
movsd  %xmm0,0xb0(%rsp)
movsd  %xmm6,0x40(%rsp)
mulsd  %xmm6,%xmm0
movsd  %xmm4,0x8(%rsp)
subsd  %xmm0,%xmm4
subsd  %xmm8,%xmm4
movapd %xmm4,0x90(%rsp)
movapd %xmm4,%xmm0
call   1040 <fabs@plt>
test   %eax,%eax
jle    1a16 <epsp+0x8e6>
xorps  %xmm1,%xmm1
cvtsi2sd %r14d,%xmm1
mulsd  0x18(%rsp),%xmm1
movsd  0x10(%rsp),%xmm0
subsd  %xmm1,%xmm0
subsd  0x70(%rsp),%xmm0
movsd  %xmm0,0x88(%rsp)
call   1040 <fabs@plt>
test   %eax,%eax
jle    1a1e <epsp+0x8ee>
add    %r12d,%r13d
xorps  %xmm1,%xmm1
cvtsi2sd %r13d,%xmm1
movsd  0x30(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
mulsd  0x50(%rsp),%xmm1
subsd  %xmm1,%xmm0
subsd  0x70(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
call   1040 <fabs@plt>
test   %eax,%eax
jle    1a34 <epsp+0x904>
xorpd  %xmm0,%xmm0
movapd 0x90(%rsp),%xmm4
ucomisd %xmm4,%xmm0
jbe    1860 <epsp+0x730>
mov    0x80(%rsp),%rsi
cmp    %ebp,%esi
movapd 0x70(%rsp),%xmm2
movsd  0x8(%rsp),%xmm5
movsd  0x40(%rsp),%xmm6
jle    1940 <epsp+0x810>
mov    %esi,%r15d
mov    0x20(%rsp),%r14
movapd 0x50(%rsp),%xmm1
movsd  0x30(%rsp),%xmm3
mov    %ebp,%eax
sub    %r15d,%eax
movapd %xmm5,%xmm8
jmp    149e <epsp+0x36e>
xchg   %ax,%ax
movapd %xmm0,%xmm10
movapd %xmm1,%xmm11
movslq %esi,%r10
lea    0x1(%rsi),%r8d
movslq %r11d,%rdx
lea    -0x1(%r11),%r9d
xor    %r14d,%r14d
xorpd  %xmm0,%xmm0
mov    %r11d,%r15d
mov    %esi,%ebp
xorpd  %xmm7,%xmm7
xorpd  %xmm4,%xmm4
xor    %r13d,%r13d
xor    %r12d,%r12d
movapd 0x70(%rsp),%xmm8
movsd  0x10(%rsp),%xmm9
movsd  0x900(%rip),%xmm5
jmp    1749 <epsp+0x619>
nopw   0x0(%rax,%rax,1)
mov    %al,%sil
add    %esi,%r13d
addsd  %xmm3,%xmm7
movsd  %xmm2,(%rbx,%rdi,8)
movsd  %xmm1,(%rbx,%rcx,8)
add    $0x1,%r15d
add    $0xffffffff,%ebp
mov    0x38(%rsp),%rsi
cmp    %ebp,%r15d
jg     1599 <epsp+0x469>
cmp    %esi,%r15d
jg     17a3 <epsp+0x673>
movslq %r15d,%rdi
add    $0xffffffffffffffff,%rdi
jmp    1776 <epsp+0x646>
nopw   0x0(%rax,%rax,1)
mov    %al,%cl
add    %ecx,%r13d
addsd  %xmm1,%xmm7
add    $0x1,%r15d
add    $0x1,%rdi
cmp    %r10,%rdi
jge    17a0 <epsp+0x670>
movsd  0x8(%rbx,%rdi,8),%xmm1
ucomisd %xmm1,%xmm6
jb     17a3 <epsp+0x673>
xor    %ecx,%ecx
ucomisd %xmm10,%xmm1
seta   %al
ja     1760 <epsp+0x630>
movapd %xmm5,%xmm1
jmp    1760 <epsp+0x630>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r8d,%r15d
cmp    %r11d,%ebp
jl     1803 <epsp+0x6d3>
movslq %ebp,%rdi
add    $0x1,%rdi
jmp    17d4 <epsp+0x6a4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addsd  %xmm1,%xmm4
add    $0x1,%r12d
add    $0xffffffff,%ebp
add    $0xffffffffffffffff,%rdi
cmp    %rdx,%rdi
jle    1800 <epsp+0x6d0>
movsd  -0x8(%rbx,%rdi,8),%xmm1
ucomisd %xmm6,%xmm1
jbe    1803 <epsp+0x6d3>
ucomisd %xmm11,%xmm1
jbe    17c0 <epsp+0x690>
addsd  %xmm1,%xmm0
add    $0x1,%r14d
jmp    17c8 <epsp+0x698>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r9d,%ebp
cmp    %ebp,%r15d
jge    1740 <epsp+0x610>
movslq %r15d,%rdi
movsd  (%rbx,%rdi,8),%xmm1
ucomisd %xmm11,%xmm1
jbe    1830 <epsp+0x700>
addsd  %xmm1,%xmm0
add    $0x1,%r14d
jmp    1838 <epsp+0x708>
cs nopw 0x0(%rax,%rax,1)
nop
addsd  %xmm1,%xmm4
add    $0x1,%r12d
movslq %ebp,%rcx
movsd  (%rbx,%rcx,8),%xmm2
xor    %esi,%esi
ucomisd %xmm10,%xmm2
seta   %al
movapd %xmm2,%xmm3
ja     1720 <epsp+0x5f0>
movapd %xmm5,%xmm3
jmp    1720 <epsp+0x5f0>
nopl   (%rax)
mov    0x38(%rsp),%rbp
cmp    %ebp,%r15d
movapd 0x70(%rsp),%xmm2
movsd  0x8(%rsp),%xmm5
movsd  0x40(%rsp),%xmm1
jg     1470 <epsp+0x340>
movslq %ebp,%rax
lea    0x1(%rbp),%r8d
movslq %r15d,%rdx
lea    -0x1(%r15),%esi
mov    %r15d,%edi
movsd  0x18(%rsp),%xmm6
movsd  0x10(%rsp),%xmm8
movsd  0x88(%rsp),%xmm7
jmp    18b8 <epsp+0x788>
nopl   0x0(%rax)
cmp    %ebp,%edi
jg     1486 <epsp+0x356>
cmp    0x38(%rsp),%edi
jg     18e7 <epsp+0x7b7>
movslq %edi,%rcx
add    $0xffffffffffffffff,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
ucomisd 0x8(%rbx,%rcx,8),%xmm6
jb     18e7 <epsp+0x7b7>
add    $0x1,%edi
add    $0x1,%rcx
cmp    %rax,%rcx
jl     18d0 <epsp+0x7a0>
mov    %r8d,%edi
cmp    %r15d,%ebp
jl     191a <epsp+0x7ea>
movslq %ebp,%rcx
add    $0x1,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%rbx,%rcx,8),%xmm0
ucomisd %xmm6,%xmm0
jbe    191a <epsp+0x7ea>
add    $0xffffffff,%ebp
add    $0xffffffffffffffff,%rcx
cmp    %rdx,%rcx
jg     1900 <epsp+0x7d0>
mov    %esi,%ebp
cmp    %ebp,%edi
jge    18b0 <epsp+0x780>
movslq %ebp,%rcx
movsd  (%rbx,%rcx,8),%xmm0
movslq %edi,%rcx
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%edi
add    $0xffffffff,%ebp
jmp    18b0 <epsp+0x780>
nopl   0x0(%rax)
movslq %ebp,%rax
lea    0x1(%rbp),%r8d
movslq %esi,%rdx
lea    -0x1(%rsi),%r9d
mov    %esi,%r15d
mov    %ebp,%edi
mov    0x20(%rsp),%r14
movapd 0x50(%rsp),%xmm1
movsd  0x30(%rsp),%xmm3
jmp    1979 <epsp+0x849>
cs nopw 0x0(%rax,%rax,1)
cmp    %edi,%r15d
jg     16bf <epsp+0x58f>
cmp    %ebp,%r15d
jg     19a8 <epsp+0x878>
movslq %r15d,%rcx
add    $0xffffffffffffffff,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
ucomisd 0x8(%rbx,%rcx,8),%xmm1
jb     19a8 <epsp+0x878>
add    $0x1,%r15d
add    $0x1,%rcx
cmp    %rax,%rcx
jl     1990 <epsp+0x860>
mov    %r8d,%r15d
cmp    %esi,%edi
jl     19db <epsp+0x8ab>
movslq %edi,%rcx
add    $0x1,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%rbx,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    19db <epsp+0x8ab>
add    $0xffffffff,%edi
add    $0xffffffffffffffff,%rcx
cmp    %rdx,%rcx
jg     19c0 <epsp+0x890>
mov    %r9d,%edi
cmp    %edi,%r15d
jge    1970 <epsp+0x840>
movslq %r15d,%rcx
movsd  (%rbx,%rcx,8),%xmm0
movslq %edi,%rcx
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%r15d
add    $0xffffffff,%edi
jmp    1970 <epsp+0x840>
subsd  %xmm0,%xmm1
divsd  0x40(%rsp),%xmm1
xor    %ebp,%ebp
movapd %xmm1,%xmm5
jmp    1a5b <epsp+0x92b>
movapd 0x50(%rsp),%xmm5
jmp    1a5b <epsp+0x92b>
movsd  0x40(%rsp),%xmm5
jmp    1a24 <epsp+0x8f4>
movsd  0x18(%rsp),%xmm5
mov    0x20(%rsp),%r14
mov    0x68(%rsp),%r15
mov    0x28(%rsp),%ebp
jmp    1a5b <epsp+0x92b>
mov    0x20(%rsp),%r14
mov    0x68(%rsp),%r15
movapd 0x50(%rsp),%xmm5
mov    0x28(%rsp),%ebp
jmp    1a5b <epsp+0x92b>
subsd  %xmm2,%xmm5
divsd  0xb0(%rsp),%xmm5
jmp    1a5b <epsp+0x92b>
xor    %ebp,%ebp
mov    0x4c(%rsp),%eax
test   %eax,%eax
jle    1c08 <epsp+0xad8>
cmp    $0x4,%eax
jb     1a86 <epsp+0x956>
lea    (%r14,%r15,8),%rax
cmp    %rbx,%rax
jbe    1b08 <epsp+0x9d8>
lea    (%rbx,%r15,8),%rax
cmp    %r14,%rax
jbe    1b08 <epsp+0x9d8>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%r15b
je     1ab4 <epsp+0x984>
movsd  (%r14,%rax,8),%xmm0
movapd %xmm5,%xmm1
cmpltsd %xmm0,%xmm1
subsd  %xmm5,%xmm0
andpd  %xmm1,%xmm0
movlpd %xmm0,(%rbx,%rax,8)
or     $0x1,%rax
add    %r15,%rcx
je     1c08 <epsp+0xad8>
nopl   (%rax)
movsd  (%r14,%rax,8),%xmm0
movapd %xmm5,%xmm1
cmpltsd %xmm0,%xmm1
subsd  %xmm5,%xmm0
andpd  %xmm1,%xmm0
movlpd %xmm0,(%rbx,%rax,8)
movsd  0x8(%r14,%rax,8),%xmm0
movapd %xmm5,%xmm1
cmpltsd %xmm0,%xmm1
subsd  %xmm5,%xmm0
andpd  %xmm1,%xmm0
movlpd %xmm0,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r15
jne    1ac0 <epsp+0x990>
jmp    1c08 <epsp+0xad8>
mov    %r15d,%eax
and    $0xfffffffc,%eax
movapd %xmm5,%xmm0
unpcklpd %xmm5,%xmm0
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1c30 <epsp+0xb00>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movupd (%r14,%rcx,8),%xmm1
movupd 0x10(%r14,%rcx,8),%xmm2
movapd %xmm0,%xmm3
cmpltpd %xmm1,%xmm3
movapd %xmm0,%xmm4
cmpltpd %xmm2,%xmm4
subpd  %xmm0,%xmm1
andpd  %xmm3,%xmm1
subpd  %xmm0,%xmm2
andpd  %xmm4,%xmm2
movupd %xmm1,(%rbx,%rcx,8)
movupd %xmm2,0x10(%rbx,%rcx,8)
movupd 0x20(%r14,%rcx,8),%xmm1
movupd 0x30(%r14,%rcx,8),%xmm2
movapd %xmm0,%xmm3
cmpltpd %xmm1,%xmm3
movapd %xmm0,%xmm4
cmpltpd %xmm2,%xmm4
subpd  %xmm0,%xmm1
andpd  %xmm3,%xmm1
subpd  %xmm0,%xmm2
andpd  %xmm4,%xmm2
movupd %xmm1,0x20(%rbx,%rcx,8)
movupd %xmm2,0x30(%rbx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1b40 <epsp+0xa10>
test   $0x1,%dl
je     1bff <epsp+0xacf>
movupd (%r14,%rcx,8),%xmm1
movupd 0x10(%r14,%rcx,8),%xmm2
movapd %xmm0,%xmm3
cmpltpd %xmm1,%xmm3
movapd %xmm0,%xmm4
cmpltpd %xmm2,%xmm4
subpd  %xmm0,%xmm1
andpd  %xmm3,%xmm1
subpd  %xmm0,%xmm2
andpd  %xmm4,%xmm2
movupd %xmm1,(%rbx,%rcx,8)
movupd %xmm2,0x10(%rbx,%rcx,8)
cmp    %r15,%rax
jne    1a88 <epsp+0x958>
mov    0xa0(%rsp),%rax
movsd  %xmm5,(%rax)
mov    0xa8(%rsp),%rax
mov    %ebp,(%rax)
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ecx,%ecx
test   $0x1,%dl
jne    1bc5 <epsp+0xa95>
jmp    1bff <epsp+0xacf>
lea    0x3e8(%rip),%rdi
call   1030 <printf@plt>
mov    $0xffffffff,%edi
call   1050 <exit@plt>

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

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