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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ free(int *);
scalar_t__ malloc(int);
double const pow(double const, double);
double Fcpd(int s, int t, const double *x, const double *y, const int *yo) {
  int q, a, b, *lt, *rt, ll, rl, i, j, *yl, *yr;
  double d, l, r;
  if (t - s < 3) {
    d = pow(pow(x[t - 1] - x[t], 2) + pow(y[t - 1] - y[t], 2), 0.5);
    for (a = s; a < t - 1; a++)
      for (b = a + 1; b <= t; b++)
        if (pow(pow(x[a] - x[b], 2) + pow(y[a] - y[b], 2), 0.5) < d)
          d = pow(pow(x[a] - x[b], 2) + pow(y[a] - y[b], 2), 0.5);
    return d;
  }
  q = (s + t) / 2;
  yl = (int *)malloc((q - s + 2) * sizeof(int));
  yr = (int *)malloc((t - q + 1) * sizeof(int));
  i = 0;
  j = 0;
  for (a = 1; a <= t - s + 1; a++)
    if (yo[a] <= q)
      yl[++i] = yo[a];
    else
      yr[++j] = yo[a];
  l = Fcpd(s, q, x, y, yl);
  if (l == 0)
    return 0;
  r = Fcpd(q + 1, t, x, y, yr);
  d = l < r ? l : r;
  r = x[q + 1] - x[q];
  if (r >= d || d == 0)
    return d;
  for (b = q; b > s && x[b - 1] > x[q + 1] - d; b--)
    ;
  ll = q - b + 1;
  for (b = q + 1; b < t && x[b + 1] < x[q] + d; b++)
    ;
  rl = b - q;
  lt = (int *)malloc((ll + 1) * sizeof(int));
  rt = (int *)malloc((rl + 1) * sizeof(int));
  i = 0;
  j = 0;
  for (a = 1; a <= q - s + 1; a++)
    if (q - yl[a] < ll)
      lt[++i] = yl[a];
  for (a = 1; a <= t - q; a++)
    if (yr[a] - q - 1 < rl)
      rt[++j] = yr[a];
  free(yl);
  free(yr);
  j = 1;
  for (i = 1; i <= ll; i++) {
    while (j <= rl && y[rt[j]] <= y[lt[i]] - d)
      j++;
    if (j == rl + 1)
      break;
    for (b = 0; b + j <= rl && y[rt[b + j]] - y[lt[i]] < d; b++) {
      r = pow(pow(x[rt[b + j]] - x[lt[i]], 2) + pow(y[rt[b + j]] - y[lt[i]], 2),
              0.5);
      if (r < d)
        d = r;
      if (d == 0)
        break;
    }
    if (d == 0)
      break;
  }
  free(lt);
  free(rt);
  return d;
}


x86 assembly (clang, -O0):
<Fcpd>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %edi,-0xc(%rbp)
mov    %esi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x10(%rbp),%eax
sub    -0xc(%rbp),%eax
cmp    $0x3,%eax
jge    1349 <Fcpd+0x209>
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x10(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  0xe75(%rip),%xmm1
call   1060 <pow@plt>
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x10(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  0xe41(%rip),%xmm1
call   1060 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  0xe1d(%rip),%xmm1
call   1060 <pow@plt>
movsd  %xmm0,-0x70(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    133a <Fcpd+0x1fa>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1327 <Fcpd+0x1e7>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  0xdcd(%rip),%xmm1
call   1060 <pow@plt>
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  0xd9e(%rip),%xmm1
call   1060 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  0xd7a(%rip),%xmm1
call   1060 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1314 <Fcpd+0x1d4>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  0xd49(%rip),%xmm1
call   1060 <pow@plt>
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  0xd1a(%rip),%xmm1
call   1060 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  0xcf6(%rip),%xmm1
call   1060 <pow@plt>
movsd  %xmm0,-0x70(%rbp)
jmp    1319 <Fcpd+0x1d9>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    120d <Fcpd+0xcd>
jmp    132c <Fcpd+0x1ec>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11f3 <Fcpd+0xb3>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1980 <Fcpd+0x840>
mov    -0xc(%rbp),%eax
add    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
sub    -0xc(%rbp),%eax
add    $0x2,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x10(%rbp),%eax
sub    -0x2c(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    -0xc(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     141f <Fcpd+0x2df>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x2c(%rbp),%eax
jg     13ee <Fcpd+0x2ae>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x60(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x54(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    140c <Fcpd+0x2cc>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x68(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x58(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1411 <Fcpd+0x2d1>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13a3 <Fcpd+0x263>
mov    -0xc(%rbp),%edi
mov    -0x2c(%rbp),%esi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x60(%rbp),%r8
call   1040 <Fcpd@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1460 <Fcpd+0x320>
jp     1460 <Fcpd+0x320>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1980 <Fcpd+0x840>
mov    -0x2c(%rbp),%edi
add    $0x1,%edi
mov    -0x10(%rbp),%esi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x68(%rbp),%r8
call   1040 <Fcpd@plt>
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    14a5 <Fcpd+0x365>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    14b2 <Fcpd+0x372>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
ucomisd -0x70(%rbp),%xmm0
jae    150b <Fcpd+0x3cb>
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    151a <Fcpd+0x3da>
jp     151a <Fcpd+0x3da>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1980 <Fcpd+0x840>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%ecx
xor    %eax,%eax
cmp    -0xc(%rbp),%ecx
mov    %al,-0xa1(%rbp)
jle    156a <Fcpd+0x42a>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  -0x70(%rbp),%xmm1
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0xa1(%rbp)
mov    -0xa1(%rbp),%al
test   $0x1,%al
jne    157d <Fcpd+0x43d>
jmp    1590 <Fcpd+0x450>
jmp    1582 <Fcpd+0x442>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1520 <Fcpd+0x3e0>
mov    -0x2c(%rbp),%eax
sub    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%ecx
xor    %eax,%eax
cmp    -0x10(%rbp),%ecx
mov    %al,-0xa2(%rbp)
jge    15ea <Fcpd+0x4aa>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0xa2(%rbp)
mov    -0xa2(%rbp),%al
test   $0x1,%al
jne    15fd <Fcpd+0x4bd>
jmp    1610 <Fcpd+0x4d0>
jmp    1602 <Fcpd+0x4c2>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15a5 <Fcpd+0x465>
mov    -0x34(%rbp),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    -0xc(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     16b8 <Fcpd+0x578>
mov    -0x2c(%rbp),%eax
mov    -0x60(%rbp),%rcx
movslq -0x30(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
cmp    -0x4c(%rbp),%eax
jge    16a5 <Fcpd+0x565>
mov    -0x60(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x40(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x54(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    16aa <Fcpd+0x56a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    165c <Fcpd+0x51c>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
cmp    %ecx,%eax
jg     171b <Fcpd+0x5db>
mov    -0x68(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    -0x2c(%rbp),%eax
sub    $0x1,%eax
cmp    -0x50(%rbp),%eax
jge    1708 <Fcpd+0x5c8>
mov    -0x68(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x48(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x58(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    170d <Fcpd+0x5cd>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    16bf <Fcpd+0x57f>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
movl   $0x1,-0x58(%rbp)
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     1964 <Fcpd+0x824>
jmp    174c <Fcpd+0x60c>
mov    -0x58(%rbp),%ecx
xor    %eax,%eax
cmp    -0x50(%rbp),%ecx
mov    %al,-0xa3(%rbp)
jg     179c <Fcpd+0x65c>
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x58(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq -0x54(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
setae  %al
mov    %al,-0xa3(%rbp)
mov    -0xa3(%rbp),%al
test   $0x1,%al
jne    17af <Fcpd+0x66f>
jmp    17bd <Fcpd+0x67d>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    174c <Fcpd+0x60c>
mov    -0x58(%rbp),%eax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    17d3 <Fcpd+0x693>
jmp    1964 <Fcpd+0x824>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%ecx
add    -0x58(%rbp),%ecx
xor    %eax,%eax
cmp    -0x50(%rbp),%ecx
mov    %al,-0xa4(%rbp)
jg     1832 <Fcpd+0x6f2>
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    -0x58(%rbp),%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq -0x54(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
subsd  (%rax,%rcx,8),%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0xa4(%rbp)
mov    -0xa4(%rbp),%al
test   $0x1,%al
jne    1845 <Fcpd+0x705>
jmp    1934 <Fcpd+0x7f4>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    -0x58(%rbp),%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq -0x54(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  0x78c(%rip),%xmm1
call   1060 <pow@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    -0x58(%rbp),%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq -0x54(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  0x748(%rip),%xmm1
call   1060 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  0x724(%rip),%xmm1
call   1060 <pow@plt>
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1904 <Fcpd+0x7c4>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1921 <Fcpd+0x7e1>
jp     1921 <Fcpd+0x7e1>
jmp    1934 <Fcpd+0x7f4>
jmp    1926 <Fcpd+0x7e6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    17da <Fcpd+0x69a>
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1951 <Fcpd+0x811>
jp     1951 <Fcpd+0x811>
jmp    1964 <Fcpd+0x824>
jmp    1956 <Fcpd+0x816>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    173b <Fcpd+0x5fb>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Fcpd>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rcx,%r13
mov    %rdx,%r14
mov    %esi,%r15d
mov    %esi,%ebx
sub    %edi,%ebx
cmp    $0x2,%ebx
jg     1288 <Fcpd+0x148>
movslq %r15d,%rbp
add    $0xffffffff,%r15d
movsd  -0x8(%r14,%rbp,8),%xmm1
movsd  (%r14,%rbp,8),%xmm0
movhpd -0x8(%r13,%rbp,8),%xmm1
movhpd 0x0(%r13,%rbp,8),%xmm0
subpd  %xmm0,%xmm1
mulpd  %xmm1,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
addsd  %xmm1,%xmm0
movsd  0xe5e(%rip),%xmm1
mov    %rdi,%rbx
call   1060 <pow@plt>
mov    %rbx,%rax
movsd  %xmm0,0x8(%rsp)
cmp    %eax,%r15d
jle    1768 <Fcpd+0x628>
lea    -0x1(%rbp),%rcx
mov    %rcx,0x10(%rsp)
movslq %eax,%r15
jmp    11db <Fcpd+0x9b>
nopw   0x0(%rax,%rax,1)
cmp    0x10(%rsp),%r15
je     1768 <Fcpd+0x628>
mov    %r15,%r12
add    $0x1,%r15
cmp    %rbp,%r12
jge    11d0 <Fcpd+0x90>
mov    %r12,%rbx
jmp    11f9 <Fcpd+0xb9>
nopl   0x0(%rax)
add    $0x1,%rbx
cmp    %rbp,%rbx
jge    11d0 <Fcpd+0x90>
movsd  (%r14,%r12,8),%xmm1
movhpd 0x0(%r13,%r12,8),%xmm1
movsd  0x8(%r14,%rbx,8),%xmm0
movhpd 0x8(%r13,%rbx,8),%xmm0
subpd  %xmm0,%xmm1
mulpd  %xmm1,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
addsd  %xmm1,%xmm0
movsd  0xdd0(%rip),%xmm1
call   1060 <pow@plt>
movsd  0x8(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jbe    11f0 <Fcpd+0xb0>
movsd  (%r14,%r12,8),%xmm1
movhpd 0x0(%r13,%r12,8),%xmm1
movsd  0x8(%r14,%rbx,8),%xmm0
movhpd 0x8(%r13,%rbx,8),%xmm0
subpd  %xmm0,%xmm1
mulpd  %xmm1,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
addsd  %xmm1,%xmm0
movsd  0xd88(%rip),%xmm1
call   1060 <pow@plt>
movsd  %xmm0,0x8(%rsp)
jmp    11f0 <Fcpd+0xb0>
mov    %r8,%r12
lea    (%r15,%rdi,1),%eax
mov    %eax,%ebp
shr    $0x1f,%ebp
add    %eax,%ebp
sar    %ebp
mov    %ebp,%eax
mov    %rdi,0x10(%rsp)
sub    %edi,%eax
mov    %rax,0x40(%rsp)
lea    0x8(,%rax,4),%edi
call   1050 <malloc@plt>
mov    %r15,%rcx
mov    %rax,%r15
mov    %rcx,0x18(%rsp)
mov    %ecx,%eax
sub    %ebp,%eax
mov    %rax,0x20(%rsp)
lea    0x4(,%rax,4),%edi
call   1050 <malloc@plt>
mov    %rbp,%rsi
mov    %ebx,%r8d
add    $0x1,%r8
mov    %r8,%r9
and    $0xfffffffffffffffe,%r9
xor    %r10d,%r10d
xor    %edx,%edx
xor    %ebp,%ebp
jmp    1309 <Fcpd+0x1c9>
nopl   0x0(%rax)
add    $0x1,%r10d
mov    %r10d,%ecx
mov    %rax,%rdi
movslq %ecx,%rcx
mov    %ebx,(%rdi,%rcx,4)
add    $0x2,%rbp
cmp    %rbp,%r9
je     1341 <Fcpd+0x201>
mov    0x4(%r12,%rbp,4),%ebx
cmp    %esi,%ebx
jle    1320 <Fcpd+0x1e0>
add    $0x1,%r10d
mov    %r10d,%ecx
mov    %rax,%rdi
jmp    1328 <Fcpd+0x1e8>
xchg   %ax,%ax
add    $0x1,%edx
mov    %edx,%ecx
mov    %r15,%rdi
movslq %ecx,%rcx
mov    %ebx,(%rdi,%rcx,4)
mov    0x8(%r12,%rbp,4),%ebx
cmp    %esi,%ebx
jg     12f0 <Fcpd+0x1b0>
add    $0x1,%edx
mov    %edx,%ecx
mov    %r15,%rdi
jmp    12fa <Fcpd+0x1ba>
test   $0x1,%r8b
je     1360 <Fcpd+0x220>
mov    0x4(%r12,%rbp,4),%ecx
cmp    %esi,%ecx
cmovg  %r10d,%edx
mov    %r15,%rdi
cmovg  %rax,%rdi
movslq %edx,%rdx
mov    %ecx,0x4(%rdi,%rdx,4)
mov    %rax,0x28(%rsp)
mov    0x10(%rsp),%rdi
mov    %r14,%rdx
mov    %r13,%rcx
mov    %r15,%r12
mov    %r15,%r8
mov    %rsi,%rbp
call   1040 <Fcpd@plt>
xorpd  %xmm2,%xmm2
xorpd  %xmm1,%xmm1
movsd  %xmm1,0x8(%rsp)
ucomisd %xmm2,%xmm0
jne    1398 <Fcpd+0x258>
jnp    1768 <Fcpd+0x628>
lea    0x1(%rbp),%r15d
mov    %r15d,%edi
mov    0x18(%rsp),%rbx
mov    %ebx,%esi
mov    %r14,%rdx
mov    %r13,%rcx
mov    0x28(%rsp),%r8
movsd  %xmm0,0x8(%rsp)
call   1040 <Fcpd@plt>
movsd  0x8(%rsp),%xmm3
minsd  %xmm0,%xmm3
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm3
jne    13d2 <Fcpd+0x292>
jnp    142b <Fcpd+0x2eb>
movslq %ebp,%rax
movsd  (%r14,%rax,8),%xmm0
movsd  0x8(%r14,%rax,8),%xmm1
movapd %xmm1,%xmm2
subsd  %xmm0,%xmm2
ucomisd %xmm3,%xmm2
jae    142b <Fcpd+0x2eb>
mov    %rbp,%rsi
subsd  %xmm3,%xmm1
mov    0x10(%rsp),%rdi
movslq %edi,%rcx
cmp    %edi,%esi
cmovl  %esi,%edi
mov    %r15d,%ebp
mov    %rax,%rdx
nopw   0x0(%rax,%rax,1)
cmp    %rcx,%rdx
jle    1436 <Fcpd+0x2f6>
movsd  -0x8(%r14,%rdx,8),%xmm2
add    $0xffffffffffffffff,%rdx
add    $0xffffffff,%ebp
ucomisd %xmm1,%xmm2
ja     1410 <Fcpd+0x2d0>
jmp    1438 <Fcpd+0x2f8>
movsd  %xmm3,0x8(%rsp)
jmp    1768 <Fcpd+0x628>
mov    %edi,%ebp
mov    %esi,%ecx
sub    %ebp,%ecx
mov    %rcx,0x38(%rsp)
addsd  %xmm3,%xmm0
add    $0x1,%rax
movslq %ebx,%rcx
cmp    %r15d,%ebx
cmovg  %ebx,%r15d
mov    %esi,%edx
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %rcx,%rax
jge    1477 <Fcpd+0x337>
add    $0x1,%edx
ucomisd 0x8(%r14,%rax,8),%xmm0
lea    0x1(%rax),%rax
ja     1460 <Fcpd+0x320>
jmp    147a <Fcpd+0x33a>
mov    %r15d,%edx
movsd  %xmm3,0x8(%rsp)
mov    %rdx,%rbx
mov    %rsi,%r15
sub    %esi,%ebx
mov    0x38(%rsp),%rax
lea    0x8(,%rax,4),%edi
call   1050 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    %rbx,0x30(%rsp)
lea    0x4(,%rbx,4),%edi
call   1050 <malloc@plt>
mov    %rax,%r10
mov    0x40(%rsp),%rax
test   %eax,%eax
mov    0x28(%rsp),%r8
js     1554 <Fcpd+0x414>
mov    %eax,%r9d
add    $0x1,%r9
test   %eax,%eax
je     1533 <Fcpd+0x3f3>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
xor    %ecx,%ecx
mov    $0x1,%edx
jmp    1502 <Fcpd+0x3c2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rsi,%rdx,1),%rdi
add    $0x2,%rdi
add    $0x2,%rdx
cmp    $0x1,%rdi
je     153a <Fcpd+0x3fa>
mov    (%r12,%rdx,4),%edi
cmp    %edi,%ebp
jg     1519 <Fcpd+0x3d9>
movslq %ecx,%rbx
add    $0x1,%ecx
mov    0x18(%rsp),%rax
mov    %edi,0x4(%rax,%rbx,4)
mov    0x4(%r12,%rdx,4),%edi
cmp    %edi,%ebp
jg     14f0 <Fcpd+0x3b0>
movslq %ecx,%rbx
add    $0x1,%ecx
mov    0x18(%rsp),%rax
mov    %edi,0x4(%rax,%rbx,4)
jmp    14f0 <Fcpd+0x3b0>
xor    %ecx,%ecx
mov    $0x1,%edx
test   $0x1,%r9b
je     1554 <Fcpd+0x414>
mov    (%r12,%rdx,4),%eax
cmp    %eax,%ebp
jg     1554 <Fcpd+0x414>
movslq %ecx,%rcx
mov    0x18(%rsp),%rdx
mov    %eax,0x4(%rdx,%rcx,4)
mov    0x20(%rsp),%rax
test   %eax,%eax
jle    1591 <Fcpd+0x451>
not    %r15d
add    $0x1,%eax
lea    -0x1(%rax),%rcx
cmp    $0x2,%eax
jne    177d <Fcpd+0x63d>
xor    %eax,%eax
mov    $0x1,%edx
test   $0x1,%cl
je     1591 <Fcpd+0x451>
mov    (%r8,%rdx,4),%ecx
add    %ecx,%r15d
cmp    0x30(%rsp),%r15d
jge    1591 <Fcpd+0x451>
cltq
mov    %ecx,0x4(%r10,%rax,4)
mov    %r10,0x20(%rsp)
mov    %r12,%rdi
mov    %r8,%rbx
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rbx
test   %ebx,%ebx
js     1742 <Fcpd+0x602>
mov    0x30(%rsp),%rsi
lea    0x1(%rsi),%eax
mov    %eax,0x28(%rsp)
movslq %esi,%rbp
add    $0x2,%ebx
mov    $0x1,%r12d
mov    $0x1,%eax
mov    %rax,0x10(%rsp)
movsd  0x8(%rsp),%xmm0
mov    0x20(%rsp),%rdx
mov    %rbx,0x38(%rsp)
nopl   0x0(%rax,%rax,1)
cmp    %esi,%r12d
jg     1640 <Fcpd+0x500>
mov    0x18(%rsp),%rax
mov    0x10(%rsp),%rcx
movslq (%rax,%rcx,4),%rax
movsd  0x0(%r13,%rax,8),%xmm1
subsd  %xmm0,%xmm1
movslq %r12d,%rax
add    $0xffffffffffffffff,%rax
cs nopw 0x0(%rax,%rax,1)
nop
movslq 0x4(%rdx,%rax,4),%rcx
ucomisd 0x0(%r13,%rcx,8),%xmm1
jb     1640 <Fcpd+0x500>
add    $0x1,%r12d
add    $0x1,%rax
cmp    %rbp,%rax
jl     1620 <Fcpd+0x4e0>
mov    0x28(%rsp),%r12d
cmp    0x28(%rsp),%r12d
je     174d <Fcpd+0x60d>
cmp    %esi,%r12d
jg     1710 <Fcpd+0x5d0>
movslq %r12d,%rbx
add    $0x1,%rbx
mov    %r12d,%r15d
movapd %xmm0,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq %r15d,%rax
movslq (%rdx,%rax,4),%rax
movsd  0x0(%r13,%rax,8),%xmm0
mov    0x18(%rsp),%rcx
mov    0x10(%rsp),%rsi
movslq (%rcx,%rsi,4),%rcx
subsd  0x0(%r13,%rcx,8),%xmm0
ucomisd %xmm0,%xmm1
jbe    1700 <Fcpd+0x5c0>
movsd  %xmm1,0x8(%rsp)
movsd  (%r14,%rax,8),%xmm1
subsd  (%r14,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x941(%rip),%xmm1
call   1060 <pow@plt>
minsd  0x8(%rsp),%xmm0
ucomisd 0x936(%rip),%xmm0
jne    16d6 <Fcpd+0x596>
jnp    1706 <Fcpd+0x5c6>
add    $0x1,%r15d
lea    0x1(%rbx),%rax
movapd %xmm0,%xmm1
cmp    %rbp,%rbx
mov    %rax,%rbx
mov    0x20(%rsp),%rdx
jle    1670 <Fcpd+0x530>
jmp    1710 <Fcpd+0x5d0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm1,%xmm0
jmp    1710 <Fcpd+0x5d0>
mov    0x20(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
ucomisd 0x8f0(%rip),%xmm0
jne    171c <Fcpd+0x5dc>
jnp    174d <Fcpd+0x60d>
mov    0x10(%rsp),%rcx
add    $0x1,%rcx
mov    0x38(%rsp),%rbx
mov    %rcx,%rax
mov    %rcx,0x10(%rsp)
cmp    %rbx,%rcx
mov    0x30(%rsp),%rsi
jne    15f0 <Fcpd+0x4b0>
jmp    174d <Fcpd+0x60d>
movsd  0x8(%rsp),%xmm0
mov    0x20(%rsp),%rdx
movsd  %xmm0,0x8(%rsp)
mov    0x18(%rsp),%rdi
mov    %rdx,%rbx
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
movsd  0x8(%rsp),%xmm0
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
xor    %eax,%eax
mov    $0x1,%edx
jmp    17a6 <Fcpd+0x666>
lea    (%rsi,%rdx,1),%rdi
add    $0x2,%rdi
add    $0x2,%rdx
cmp    $0x1,%rdi
je     1577 <Fcpd+0x437>
mov    (%r8,%rdx,4),%edi
lea    (%rdi,%r15,1),%ebp
cmp    0x30(%rsp),%ebp
jge    17bf <Fcpd+0x67f>
movslq %eax,%rbp
add    $0x1,%eax
mov    %edi,0x4(%r10,%rbp,4)
mov    0x4(%r8,%rdx,4),%edi
lea    (%rdi,%r15,1),%ebp
cmp    0x30(%rsp),%ebp
jge    1790 <Fcpd+0x650>
movslq %eax,%rbp
add    $0x1,%eax
mov    %edi,0x4(%r10,%rbp,4)
jmp    1790 <Fcpd+0x650>

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

LLVM IR (-O2):
define double @Fcpd(i32 %0, i32 %1, double* %2, double* %3, i32* nocapture %4) {
%6 = sub nsw i32 %1, %0
%7 = icmp slt i32 %6, 3
br i1 %7, label %8, label %85
8: ; preds = %5
%9 = add nsw i32 %1, -1
%10 = sext i32 %9 to i64
%11 = getelementptr inbounds double, double* %2, i64 %10
%12 = load double, double* %11
%13 = sext i32 %1 to i64
%14 = getelementptr inbounds double, double* %2, i64 %13
%15 = load double, double* %14
%16 = getelementptr inbounds double, double* %3, i64 %10
%17 = load double, double* %16
%18 = getelementptr inbounds double, double* %3, i64 %13
%19 = load double, double* %18
%20 = insertelement <2 x double> poison, double %12, i64 0
%21 = insertelement <2 x double> %20, double %17, i64 1
%22 = insertelement <2 x double> poison, double %15, i64 0
%23 = insertelement <2 x double> %22, double %19, i64 1
%24 = fsub <2 x double> %21, %23
%25 = fmul <2 x double> %24, %24
%26 = shufflevector <2 x double> %25, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%27 = fadd <2 x double> %25, %26
%28 = extractelement <2 x double> %27, i64 0
%29 = tail call double @pow(double %28, double 5.000000e-01)
%30 = icmp sgt i32 %9, %0
br i1 %30, label %31, label %398
31: ; preds = %8
%32 = sext i32 %0 to i64
br label %36
33: ; preds = %81, %36
%34 = phi double [ %39, %36 ], [ %82, %81 ]
%35 = icmp eq i64 %41, %10
br i1 %35, label %398, label %36
36: ; preds = %31, %33
%37 = phi i64 [ %32, %31 ], [ %41, %33 ]
%38 = phi i64 [ %32, %31 ], [ %40, %33 ]
%39 = phi double [ %29, %31 ], [ %34, %33 ]
%40 = add nsw i64 %38, 1
%41 = add nsw i64 %37, 1
%42 = icmp slt i64 %37, %13
br i1 %42, label %43, label %33
43: ; preds = %36
%44 = getelementptr inbounds double, double* %2, i64 %37
%45 = getelementptr inbounds double, double* %3, i64 %37
br label %46
46: ; preds = %43, %81
%47 = phi i64 [ %40, %43 ], [ %83, %81 ]
%48 = phi double [ %39, %43 ], [ %82, %81 ]
%49 = load double, double* %44
%50 = getelementptr inbounds double, double* %2, i64 %47
%51 = load double, double* %50
%52 = load double, double* %45
%53 = getelementptr inbounds double, double* %3, i64 %47
%54 = load double, double* %53
%55 = insertelement <2 x double> poison, double %49, i64 0
%56 = insertelement <2 x double> %55, double %52, i64 1
%57 = insertelement <2 x double> poison, double %51, i64 0
%58 = insertelement <2 x double> %57, double %54, i64 1
%59 = fsub <2 x double> %56, %58
%60 = fmul <2 x double> %59, %59
%61 = shufflevector <2 x double> %60, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%62 = fadd <2 x double> %60, %61
%63 = extractelement <2 x double> %62, i64 0
%64 = tail call double @pow(double %63, double 5.000000e-01)
%65 = fcmp olt double %64, %48
br i1 %65, label %66, label %81
66: ; preds = %46
%67 = load double, double* %44
%68 = load double, double* %50
%69 = load double, double* %45
%70 = load double, double* %53
%71 = insertelement <2 x double> poison, double %67, i64 0
%72 = insertelement <2 x double> %71, double %69, i64 1
%73 = insertelement <2 x double> poison, double %68, i64 0
%74 = insertelement <2 x double> %73, double %70, i64 1
%75 = fsub <2 x double> %72, %74
%76 = fmul <2 x double> %75, %75
%77 = shufflevector <2 x double> %76, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%78 = fadd <2 x double> %76, %77
%79 = extractelement <2 x double> %78, i64 0
%80 = tail call double @pow(double %79, double 5.000000e-01)
br label %81
81: ; preds = %46, %66
%82 = phi double [ %80, %66 ], [ %48, %46 ]
%83 = add nsw i64 %47, 1
%84 = icmp slt i64 %47, %13
br i1 %84, label %46, label %33
85: ; preds = %5
%86 = add nsw i32 %1, %0
%87 = sdiv i32 %86, 2
%88 = sub nsw i32 %87, %0
%89 = shl i32 %88, 2
%90 = add i32 %89, 8
%91 = tail call i64 @malloc(i32 %90)
%92 = inttoptr i64 %91 to i32*
%93 = sub nsw i32 %1, %87
%94 = shl i32 %93, 2
%95 = add i32 %94, 4
%96 = tail call i64 @malloc(i32 %95)
%97 = inttoptr i64 %96 to i32*
%98 = zext i32 %6 to i64
%99 = add nuw nsw i64 %98, 1
%100 = and i64 %99, 1
%101 = and i64 %99, 8589934590
br label %102
102: ; preds = %129, %85
%103 = phi i64 [ 1, %85 ], [ %136, %129 ]
%104 = phi i32 [ 0, %85 ], [ %133, %129 ]
%105 = phi i32 [ 0, %85 ], [ %132, %129 ]
%106 = phi i64 [ 0, %85 ], [ %137, %129 ]
%107 = getelementptr inbounds i32, i32* %4, i64 %103
%108 = load i32, i32* %107
%109 = icmp sgt i32 %108, %87
br i1 %109, label %112, label %110
110: ; preds = %102
%111 = add nsw i32 %105, 1
br label %114
112: ; preds = %102
%113 = add nsw i32 %104, 1
br label %114
114: ; preds = %110, %112
%115 = phi i32 [ %111, %110 ], [ %113, %112 ]
%116 = phi i32* [ %92, %110 ], [ %97, %112 ]
%117 = phi i32 [ %111, %110 ], [ %105, %112 ]
%118 = phi i32 [ %104, %110 ], [ %113, %112 ]
%119 = sext i32 %115 to i64
%120 = getelementptr inbounds i32, i32* %116, i64 %119
store i32 %108, i32* %120
%121 = add nuw nsw i64 %103, 1
%122 = getelementptr inbounds i32, i32* %4, i64 %121
%123 = load i32, i32* %122
%124 = icmp sgt i32 %123, %87
br i1 %124, label %127, label %125
125: ; preds = %114
%126 = add nsw i32 %117, 1
br label %129
127: ; preds = %114
%128 = add nsw i32 %118, 1
br label %129
129: ; preds = %127, %125
%130 = phi i32 [ %126, %125 ], [ %128, %127 ]
%131 = phi i32* [ %92, %125 ], [ %97, %127 ]
%132 = phi i32 [ %126, %125 ], [ %117, %127 ]
%133 = phi i32 [ %118, %125 ], [ %128, %127 ]
%134 = sext i32 %130 to i64
%135 = getelementptr inbounds i32, i32* %131, i64 %134
store i32 %123, i32* %135
%136 = add nuw nsw i64 %103, 2
%137 = add i64 %106, 2
%138 = icmp eq i64 %137, %101
br i1 %138, label %139, label %102
139: ; preds = %129
%140 = icmp eq i64 %100, 0
br i1 %140, label %150, label %141
141: ; preds = %139
%142 = getelementptr inbounds i32, i32* %4, i64 %136
%143 = load i32, i32* %142
%144 = icmp sgt i32 %143, %87
%145 = select i1 %144, i32 %133, i32 %132
%146 = select i1 %144, i32* %97, i32* %92
%147 = add nsw i32 %145, 1
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds i32, i32* %146, i64 %148
store i32 %143, i32* %149
br label %150
150: ; preds = %139, %141
%151 = tail call double @Fcpd(i32 %0, i32 %87, double* %2, double* %3, i32* %92)
%152 = fcmp oeq double %151, 0.000000e+00
br i1 %152, label %398, label %153
153: ; preds = %150
%154 = add nsw i32 %87, 1
%155 = tail call double @Fcpd(i32 %154, i32 %1, double* %2, double* %3, i32* %97)
%156 = fcmp olt double %151, %155
%157 = select i1 %156, double %151, double %155
%158 = sext i32 %154 to i64
%159 = getelementptr inbounds double, double* %2, i64 %158
%160 = load double, double* %159
%161 = sext i32 %87 to i64
%162 = getelementptr inbounds double, double* %2, i64 %161
%163 = load double, double* %162
%164 = fsub double %160, %163
%165 = fcmp oge double %164, %157
%166 = fcmp oeq double %157, 0.000000e+00
%167 = or i1 %166, %165
br i1 %167, label %398, label %168
168: ; preds = %153
%169 = fsub double %160, %157
%170 = sext i32 %0 to i64
%171 = call i32 @llvm.smin.i32(i32 %87, i32 %0)
br label %172
172: ; preds = %168, %175
%173 = phi i64 [ %161, %168 ], [ %176, %175 ]
%174 = icmp sgt i64 %173, %170
br i1 %174, label %175, label %182
175: ; preds = %172
%176 = add nsw i64 %173, -1
%177 = getelementptr inbounds double, double* %2, i64 %176
%178 = load double, double* %177
%179 = fcmp ogt double %178, %169
br i1 %179, label %172, label %180
180: ; preds = %175
%181 = trunc i64 %173 to i32
br label %182
182: ; preds = %172, %180
%183 = phi i32 [ %181, %180 ], [ %171, %172 ]
%184 = sub nsw i32 %87, %183
%185 = fadd double %163, %157
%186 = add nsw i64 %161, 1
%187 = sext i32 %1 to i64
%188 = call i32 @llvm.smax.i32(i32 %1, i32 %154)
br label %189
189: ; preds = %192, %182
%190 = phi i64 [ %193, %192 ], [ %186, %182 ]
%191 = icmp slt i64 %190, %187
br i1 %191, label %192, label %199
192: ; preds = %189
%193 = add nsw i64 %190, 1
%194 = getelementptr inbounds double, double* %2, i64 %193
%195 = load double, double* %194
%196 = fcmp olt double %195, %185
br i1 %196, label %189, label %197
197: ; preds = %192
%198 = trunc i64 %190 to i32
br label %199
199: ; preds = %189, %197
%200 = phi i32 [ %198, %197 ], [ %188, %189 ]
%201 = sub nsw i32 %200, %87
%202 = shl i32 %184, 2
%203 = add i32 %202, 8
%204 = tail call i64 @malloc(i32 %203)
%205 = inttoptr i64 %204 to i32*
%206 = add nsw i32 %201, 1
%207 = shl i32 %206, 2
%208 = tail call i64 @malloc(i32 %207)
%209 = inttoptr i64 %208 to i32*
%210 = icmp slt i32 %88, 0
br i1 %210, label %230, label %211
211: ; preds = %199
%212 = zext i32 %88 to i64
%213 = add nuw nsw i64 %212, 1
%214 = and i64 %213, 1
%215 = icmp eq i32 %88, 0
br i1 %215, label %218, label %216
216: ; preds = %211
%217 = and i64 %213, 8589934590
br label %242
218: ; preds = %263, %211
%219 = phi i64 [ 1, %211 ], [ %265, %263 ]
%220 = phi i32 [ 0, %211 ], [ %264, %263 ]
%221 = icmp eq i64 %214, 0
br i1 %221, label %230, label %222
222: ; preds = %218
%223 = getelementptr inbounds i32, i32* %92, i64 %219
%224 = load i32, i32* %223
%225 = icmp sgt i32 %183, %224
br i1 %225, label %230, label %226
226: ; preds = %222
%227 = add nsw i32 %220, 1
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds i32, i32* %205, i64 %228
store i32 %224, i32* %229
br label %230
230: ; preds = %218, %226, %222, %199
%231 = icmp slt i32 %93, 1
br i1 %231, label %309, label %232
232: ; preds = %230
%233 = xor i32 %87, -1
%234 = add i32 %1, 1
%235 = sub i32 %234, %87
%236 = zext i32 %235 to i64
%237 = add nsw i64 %236, -1
%238 = and i64 %237, 1
%239 = icmp eq i32 %235, 2
br i1 %239, label %296, label %240
240: ; preds = %232
%241 = and i64 %237, -2
br label %268
242: ; preds = %263, %216
%243 = phi i64 [ 1, %216 ], [ %265, %263 ]
%244 = phi i32 [ 0, %216 ], [ %264, %263 ]
%245 = phi i64 [ 0, %216 ], [ %266, %263 ]
%246 = getelementptr inbounds i32, i32* %92, i64 %243
%247 = load i32, i32* %246
%248 = icmp sgt i32 %183, %247
br i1 %248, label %253, label %249
249: ; preds = %242
%250 = add nsw i32 %244, 1
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds i32, i32* %205, i64 %251
store i32 %247, i32* %252
br label %253
253: ; preds = %242, %249
%254 = phi i32 [ %250, %249 ], [ %244, %242 ]
%255 = add nuw nsw i64 %243, 1
%256 = getelementptr inbounds i32, i32* %92, i64 %255
%257 = load i32, i32* %256
%258 = icmp sgt i32 %183, %257
br i1 %258, label %263, label %259
259: ; preds = %253
%260 = add nsw i32 %254, 1
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds i32, i32* %205, i64 %261
store i32 %257, i32* %262
br label %263
263: ; preds = %259, %253
%264 = phi i32 [ %260, %259 ], [ %254, %253 ]
%265 = add nuw nsw i64 %243, 2
%266 = add i64 %245, 2
%267 = icmp eq i64 %266, %217
br i1 %267, label %218, label %242
268: ; preds = %291, %240
%269 = phi i64 [ 1, %240 ], [ %293, %291 ]
%270 = phi i32 [ 0, %240 ], [ %292, %291 ]
%271 = phi i64 [ 0, %240 ], [ %294, %291 ]
%272 = getelementptr inbounds i32, i32* %97, i64 %269
%273 = load i32, i32* %272
%274 = add i32 %273, %233
%275 = icmp slt i32 %274, %201
br i1 %275, label %276, label %280
276: ; preds = %268
%277 = add nsw i32 %270, 1
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds i32, i32* %209, i64 %278
store i32 %273, i32* %279
br label %280
280: ; preds = %268, %276
%281 = phi i32 [ %277, %276 ], [ %270, %268 ]
%282 = add nuw nsw i64 %269, 1
%283 = getelementptr inbounds i32, i32* %97, i64 %282
%284 = load i32, i32* %283
%285 = add i32 %284, %233
%286 = icmp slt i32 %285, %201
br i1 %286, label %287, label %291
287: ; preds = %280
%288 = add nsw i32 %281, 1
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds i32, i32* %209, i64 %289
store i32 %284, i32* %290
br label %291
291: ; preds = %287, %280
%292 = phi i32 [ %288, %287 ], [ %281, %280 ]
%293 = add nuw nsw i64 %269, 2
%294 = add i64 %271, 2
%295 = icmp eq i64 %294, %241
br i1 %295, label %296, label %268
296: ; preds = %291, %232
%297 = phi i64 [ 1, %232 ], [ %293, %291 ]
%298 = phi i32 [ 0, %232 ], [ %292, %291 ]
%299 = icmp eq i64 %238, 0
br i1 %299, label %309, label %300
300: ; preds = %296
%301 = getelementptr inbounds i32, i32* %97, i64 %297
%302 = load i32, i32* %301
%303 = add i32 %302, %233
%304 = icmp slt i32 %303, %201
br i1 %304, label %305, label %309
305: ; preds = %300
%306 = add nsw i32 %298, 1
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds i32, i32* %209, i64 %307
store i32 %302, i32* %308
br label %309
309: ; preds = %296, %305, %300, %230
%310 = tail call i32 @free(i32* %92)
%311 = tail call i32 @free(i32* %97)
%312 = icmp slt i32 %184, 0
br i1 %312, label %394, label %313
313: ; preds = %309
%314 = sext i32 %201 to i64
%315 = add i32 %200, 1
%316 = sub i32 %315, %87
%317 = add nsw i32 %87, 2
%318 = sub i32 %317, %183
%319 = zext i32 %318 to i64
br label %320
320: ; preds = %388, %313
%321 = phi i64 [ 1, %313 ], [ %391, %388 ]
%322 = phi double [ %157, %313 ], [ %389, %388 ]
%323 = phi i32 [ 1, %313 ], [ %347, %388 ]
%324 = icmp sgt i32 %323, %201
br i1 %324, label %346, label %325
325: ; preds = %320
%326 = getelementptr inbounds i32, i32* %205, i64 %321
%327 = load i32, i32* %326
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds double, double* %3, i64 %328
%330 = load double, double* %329
%331 = fsub double %330, %322
%332 = sext i32 %323 to i64
br label %333
333: ; preds = %325, %341
%334 = phi i64 [ %332, %325 ], [ %342, %341 ]
%335 = getelementptr inbounds i32, i32* %209, i64 %334
%336 = load i32, i32* %335
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds double, double* %3, i64 %337
%339 = load double, double* %338
%340 = fcmp ugt double %339, %331
br i1 %340, label %344, label %341
341: ; preds = %333
%342 = add nsw i64 %334, 1
%343 = icmp slt i64 %334, %314
br i1 %343, label %333, label %346
344: ; preds = %333
%345 = trunc i64 %334 to i32
br label %346
346: ; preds = %341, %344, %320
%347 = phi i32 [ %323, %320 ], [ %345, %344 ], [ %316, %341 ]
%348 = icmp eq i32 %347, %206
br i1 %348, label %394, label %349
349: ; preds = %346
%350 = icmp sgt i32 %347, %201
br i1 %350, label %388, label %351
351: ; preds = %349
%352 = getelementptr inbounds i32, i32* %205, i64 %321
%353 = sext i32 %347 to i64
br label %354
354: ; preds = %370, %351
%355 = phi i64 [ %383, %370 ], [ 0, %351 ]
%356 = phi i32 [ %387, %370 ], [ %347, %351 ]
%357 = phi double [ %381, %370 ], [ %322, %351 ]
%358 = sext i32 %356 to i64
%359 = getelementptr inbounds i32, i32* %209, i64 %358
%360 = load i32, i32* %359
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds double, double* %3, i64 %361
%363 = load double, double* %362
%364 = load i32, i32* %352
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds double, double* %3, i64 %365
%367 = load double, double* %366
%368 = fsub double %363, %367
%369 = fcmp olt double %368, %357
br i1 %369, label %370, label %388
370: ; preds = %354
%371 = getelementptr inbounds double, double* %2, i64 %361
%372 = load double, double* %371
%373 = getelementptr inbounds double, double* %2, i64 %365
%374 = load double, double* %373
%375 = fsub double %372, %374
%376 = fmul double %375, %375
%377 = fmul double %368, %368
%378 = fadd double %377, %376
%379 = tail call double @pow(double %378, double 5.000000e-01)
%380 = fcmp olt double %379, %357
%381 = select i1 %380, double %379, double %357
%382 = fcmp oeq double %381, 0.000000e+00
%383 = add nuw i64 %355, 1
%384 = add nsw i64 %383, %353
%385 = icmp sgt i64 %384, %314
%386 = select i1 %382, i1 true, i1 %385
%387 = trunc i64 %384 to i32
br i1 %386, label %388, label %354
388: ; preds = %354, %370, %349
%389 = phi double [ %322, %349 ], [ %381, %370 ], [ %357, %354 ]
%390 = fcmp oeq double %389, 0.000000e+00
%391 = add nuw nsw i64 %321, 1
%392 = icmp eq i64 %391, %319
%393 = select i1 %390, i1 true, i1 %392
br i1 %393, label %394, label %320
394: ; preds = %346, %388, %309
%395 = phi double [ %157, %309 ], [ %389, %388 ], [ %322, %346 ]
%396 = tail call i32 @free(i32* %205)
%397 = tail call i32 @free(i32* %209)
br label %398
398: ; preds = %33, %8, %153, %150, %394
%399 = phi double [ %395, %394 ], [ 0.000000e+00, %150 ], [ %157, %153 ], [ %29, %8 ], [ %34, %33 ]
ret double %399
}