#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 */
double sqrt(double);
int BEthresh(double *Scores, int Nscores, double *wr, int *indsel,
             int *pointNumRem, double *pointTau) {
  int M = Nscores + 1;
  double vmin = -1e100;
  int imin = -1;
  int inrem = -1;
  int i = 0;
  int aux = 0;
  int iC = 0;
  int iR = 0;
  int iL = 0;
  double h0R = 0;
  double h0L = 0;
  double Tau = *pointTau;
  int NumRem = *pointNumRem;
  while (NumRem > 0) {
    imin = 0;
    vmin = Scores[indsel[imin]];
    for (i = 1; i < NumRem; i++) {
      aux = indsel[i];
      if (Scores[aux] < vmin) {
        imin = i;
        vmin = Scores[aux];
      }
    }
    inrem = indsel[imin];
    if ((vmin > Tau) && (Tau >= 0)) {
      break;
    }
    if (imin == -1) {
      NumRem = 0;
      vmin = 0;
      break;
    }
    iC = indsel[imin];
    if (NumRem == 1) {
      aux = indsel[imin];
      Scores[aux] = 0;
      wr[aux] = 0;
      NumRem = 0;
      break;
    }
    if (imin == 0) {
      iR = indsel[imin + 1];
      iL = 0;
      wr[iR] = wr[iR] + (double)sqrt((double)(M - iR - 1) / (M - iC - 1) *
                                     (double)(iR + 1) / (iC + 1)) *
                            (double)(iC + 1 - iL) / (iR + 1 - iL) *
                            (double)wr[iC];
      wr[iC] = 0;
      Scores[iC] = 0;
      iC = indsel[imin + 1];
      if (imin + 1 == NumRem - 1) {
        iR = M - 1;
      } else {
        iR = indsel[imin + 2];
      }
      h0R = (double)(M - iC - 1) * (iC + 1) / M * (iR + 1 - iL) / (iR - iC) /
            (iC + 1 - iL);
      if (wr[iC] >= 0) {
        Scores[iC] = (double)(wr[iC] / sqrt(h0R));
      } else {
        Scores[iC] = (double)(-wr[iC] / sqrt(h0R));
      }
    } else if (imin == NumRem - 1) {
      iL = indsel[imin - 1];
      iR = M;
      wr[iL] = wr[iL] + sqrt((double)(M - iL - 1) / (M - iC - 1) *
                             (double)(iL + 1) / (iC + 1)) *
                            (double)(iR - iC - 1) / (iR - iL - 1) * wr[iC];
      wr[iC] = 0;
      Scores[iC] = 0;
      if (imin - 1 == 0) {
        iL = -1;
      } else {
        iL = indsel[imin - 2];
      }
      iC = indsel[imin - 1];
      h0L = (double)(M - iC - 1) * (iC + 1) / M * (iR - iL - 1) /
            (iR - iC - 1) / (iC - iL);
      if (wr[iC] >= 0) {
        Scores[iC] = (double)(wr[iC] / sqrt(h0L));
      } else {
        Scores[iC] = (double)(-wr[iC] / sqrt(h0L));
      }
    } else {
      iR = indsel[imin + 1];
      iL = indsel[imin - 1];
      wr[iR] = wr[iR] + sqrt((double)(M - iR - 1) / (M - iC - 1) *
                             (double)(iR + 1) / (iC + 1)) *
                            (double)(iC - iL) / (iR - iL) * wr[iC];
      wr[iL] = wr[iL] + sqrt((double)(M - iL - 1) / (M - iC - 1) *
                             (double)(iL + 1) / (iC + 1)) *
                            (double)(iR - iC) / (iR - iL) * wr[iC];
      wr[iC] = 0;
      Scores[iC] = 0;
      iL = indsel[imin - 1];
      iC = indsel[imin + 1];
      if (imin + 1 == NumRem - 1) {
        iR = M - 1;
      } else {
        iR = indsel[imin + 2];
      }
      h0R = (double)(M - iC - 1) * (iC + 1) / M * (iR - iL) / (iR - iC) /
            (iC - iL);
      if (wr[iC] >= 0) {
        Scores[iC] = (double)(wr[iC] / sqrt(h0R));
      } else {
        Scores[iC] = (double)(-wr[iC] / sqrt(h0R));
      }
      if (imin - 1 == 0) {
        iL = -1;
      } else {
        iL = indsel[imin - 2];
      }
      iC = indsel[imin - 1];
      iR = indsel[imin + 1];
      h0L = (double)(M - iC - 1) * (iC + 1) / M * (iR - iL) / (iR - iC) /
            (iC - iL);
      if (wr[iC] >= 0) {
        Scores[iC] = (double)(wr[iC] / sqrt(h0L));
      } else {
        Scores[iC] = (double)(-wr[iC] / sqrt(h0L));
      }
    }
    NumRem = NumRem - 1;
    for (i = imin; i < NumRem; i++) {
      indsel[i] = indsel[i + 1];
    }
    if (Tau < 0) {
      break;
    }
  }
  *pointTau = vmin;
  *pointNumRem = NumRem;
  return (inrem);
}


x86 assembly (clang, -O0):
<BEthresh>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
movsd  0xebd(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0xffffffff,-0x44(%rbp)
movl   $0xffffffff,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x7c(%rbp)
cmpl   $0x0,-0x7c(%rbp)
jle    1bcf <BEthresh+0xabf>
movl   $0x0,-0x44(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x44(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    1232 <BEthresh+0x122>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    121f <BEthresh+0x10f>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    1224 <BEthresh+0x114>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    11d1 <BEthresh+0xc1>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm0
ucomisd -0x78(%rbp),%xmm0
jbe    1267 <BEthresh+0x157>
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1267 <BEthresh+0x157>
jmp    1bcf <BEthresh+0xabf>
cmpl   $0xffffffff,-0x44(%rbp)
jne    1285 <BEthresh+0x175>
movl   $0x0,-0x7c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    1bcf <BEthresh+0xabf>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
cmpl   $0x1,-0x7c(%rbp)
jne    12d7 <BEthresh+0x1c7>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x7c(%rbp)
jmp    1bcf <BEthresh+0xabf>
cmpl   $0x0,-0x44(%rbp)
jne    150d <BEthresh+0x3fd>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x34(%rbp),%eax
sub    -0x58(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    -0x34(%rbp),%eax
sub    -0x54(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
mov    -0x58(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x54(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x54(%rbp),%eax
add    $0x1,%eax
sub    -0x5c(%rbp),%eax
cvtsi2sd %eax,%xmm2
mulsd  %xmm2,%xmm0
mov    -0x58(%rbp),%eax
add    $0x1,%eax
sub    -0x5c(%rbp),%eax
cvtsi2sd %eax,%xmm2
divsd  %xmm2,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    -0x7c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    13f0 <BEthresh+0x2e0>
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1403 <BEthresh+0x2f3>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
mov    -0x34(%rbp),%eax
sub    -0x54(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    -0x54(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
cvtsi2sdl -0x34(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x58(%rbp),%eax
add    $0x1,%eax
sub    -0x5c(%rbp),%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x58(%rbp),%eax
sub    -0x54(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
mov    -0x54(%rbp),%eax
add    $0x1,%eax
sub    -0x5c(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     14b6 <BEthresh+0x3a6>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1508 <BEthresh+0x3f8>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b73 <BEthresh+0xa63>
mov    -0x44(%rbp),%eax
mov    -0x7c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1742 <BEthresh+0x632>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x34(%rbp),%eax
sub    -0x5c(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    -0x34(%rbp),%eax
sub    -0x54(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x54(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0x58(%rbp),%eax
sub    -0x54(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm2
mulsd  %xmm2,%xmm0
mov    -0x58(%rbp),%eax
sub    -0x5c(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm2
divsd  %xmm2,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jne    1612 <BEthresh+0x502>
movl   $0xffffffff,-0x5c(%rbp)
jmp    1625 <BEthresh+0x515>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x34(%rbp),%eax
sub    -0x54(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    -0x54(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
cvtsi2sdl -0x34(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x58(%rbp),%eax
sub    -0x5c(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x58(%rbp),%eax
sub    -0x54(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
mov    -0x54(%rbp),%eax
sub    -0x5c(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     16eb <BEthresh+0x5db>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    173d <BEthresh+0x62d>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b6e <BEthresh+0xa5e>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x34(%rbp),%eax
sub    -0x58(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    -0x34(%rbp),%eax
sub    -0x54(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
mov    -0x58(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x54(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  -0xc0(%rbp),%xmm1
ff
mov    -0x54(%rbp),%eax
sub    -0x5c(%rbp),%eax
cvtsi2sd %eax,%xmm2
mulsd  %xmm2,%xmm0
mov    -0x58(%rbp),%eax
sub    -0x5c(%rbp),%eax
cvtsi2sd %eax,%xmm2
divsd  %xmm2,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x34(%rbp),%eax
sub    -0x5c(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    -0x34(%rbp),%eax
sub    -0x54(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x54(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  -0xb8(%rbp),%xmm1
ff
mov    -0x58(%rbp),%eax
sub    -0x54(%rbp),%eax
cvtsi2sd %eax,%xmm2
mulsd  %xmm2,%xmm0
mov    -0x58(%rbp),%eax
sub    -0x5c(%rbp),%eax
cvtsi2sd %eax,%xmm2
divsd  %xmm2,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    -0x7c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1904 <BEthresh+0x7f4>
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1917 <BEthresh+0x807>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
mov    -0x34(%rbp),%eax
sub    -0x54(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    -0x54(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
cvtsi2sdl -0x34(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x58(%rbp),%eax
sub    -0x5c(%rbp),%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x58(%rbp),%eax
sub    -0x54(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
mov    -0x54(%rbp),%eax
sub    -0x5c(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     19c4 <BEthresh+0x8b4>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1a16 <BEthresh+0x906>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jne    1a31 <BEthresh+0x921>
movl   $0xffffffff,-0x5c(%rbp)
jmp    1a44 <BEthresh+0x934>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
mov    -0x34(%rbp),%eax
sub    -0x54(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    -0x54(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
cvtsi2sdl -0x34(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x58(%rbp),%eax
sub    -0x5c(%rbp),%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x58(%rbp),%eax
sub    -0x54(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
mov    -0x54(%rbp),%eax
sub    -0x5c(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1b17 <BEthresh+0xa07>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0xd8(%rbp),%xmm0
divsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b69 <BEthresh+0xa59>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0xe0(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b6e <BEthresh+0xa5e>
jmp    1b73 <BEthresh+0xa63>
mov    -0x7c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    1bb7 <BEthresh+0xaa7>
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1b82 <BEthresh+0xa72>
xorps  %xmm0,%xmm0
ucomisd -0x78(%rbp),%xmm0
jbe    1bca <BEthresh+0xaba>
jmp    1bcf <BEthresh+0xabf>
jmp    119f <BEthresh+0x8f>
movsd  -0x40(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x7c(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x48(%rbp),%eax
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<BEthresh>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    (%r8),%r15d
test   %r15d,%r15d
jle    1a07 <BEthresh+0x8f7>
mov    %rcx,%r14
mov    %rdi,%r13
mov    %r8,0x40(%rsp)
mov    %r9,0x38(%rsp)
movsd  (%r9),%xmm4
lea    0x1(%rsi),%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x10(%rsp)
lea    0x34(%rcx),%rax
mov    %rax,0x98(%rsp)
lea    -0x1(%r15),%r10
xor    %r11d,%r11d
xorpd  %xmm5,%xmm5
mov    %r15,%rax
mov    %r15,0xa0(%rsp)
mov    %rdx,0x28(%rsp)
mov    %rsi,0x20(%rsp)
movsd  %xmm4,0x78(%rsp)
jmp    11a2 <BEthresh+0x92>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r11
add    $0xffffffffffffffff,%r10
ucomisd %xmm4,%xmm5
ja     1a1a <BEthresh+0x90a>
movslq (%r14),%rbx
movsd  0x0(%r13,%rbx,8),%xmm6
cmp    $0x2,%r15
mov    %r10,0x88(%rsp)
mov    %r11,0x80(%rsp)
jl     11e0 <BEthresh+0xd0>
mov    %r15d,%eax
lea    -0x1(%rax),%r8
add    $0xfffffffffffffffe,%rax
cmp    $0x3,%rax
jae    1200 <BEthresh+0xf0>
xor    %r12d,%r12d
mov    $0x1,%eax
jmp    1295 <BEthresh+0x185>
ucomisd %xmm5,%xmm4
jb     11f0 <BEthresh+0xe0>
ucomisd %xmm4,%xmm6
ja     1a1a <BEthresh+0x90a>
cmp    $0x1,%r15
jne    137b <BEthresh+0x26b>
jmp    1a29 <BEthresh+0x919>
nop
mov    %r8,%r9
and    $0xfffffffffffffffc,%r9
xor    %r12d,%r12d
mov    $0x1,%eax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq (%r14,%rax,4),%rdi
movsd  0x0(%r13,%rdi,8),%xmm0
ucomisd %xmm0,%xmm6
cmova  %eax,%r12d
minsd  %xmm6,%xmm0
movslq 0x4(%r14,%rax,4),%rdi
movsd  0x0(%r13,%rdi,8),%xmm1
ucomisd %xmm1,%xmm0
lea    0x1(%rax),%edi
cmovbe %r12d,%edi
minsd  %xmm0,%xmm1
lea    0x2(%rax),%ebp
movslq 0x8(%r14,%rax,4),%rcx
movsd  0x0(%r13,%rcx,8),%xmm0
ucomisd %xmm0,%xmm1
cmovbe %edi,%ebp
minsd  %xmm1,%xmm0
movslq 0xc(%r14,%rax,4),%rcx
movsd  0x0(%r13,%rcx,8),%xmm6
ucomisd %xmm6,%xmm0
lea    0x3(%rax),%r12d
cmovbe %ebp,%r12d
minsd  %xmm0,%xmm6
add    $0x4,%rax
add    $0x4,%rbx
cmp    %r9,%rbx
jne    1220 <BEthresh+0x110>
movapd %xmm6,%xmm7
test   $0x3,%r8b
je     12d5 <BEthresh+0x1c5>
mov    %r10d,%ecx
and    $0x3,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movslq (%r14,%rax,4),%rdi
movsd  0x0(%r13,%rdi,8),%xmm7
ucomisd %xmm7,%xmm6
cmova  %eax,%r12d
minsd  %xmm6,%xmm7
add    $0x1,%rax
movapd %xmm7,%xmm6
add    $0xffffffffffffffff,%rcx
jne    12b0 <BEthresh+0x1a0>
ucomisd %xmm5,%xmm4
movslq %r12d,%rbp
mov    (%r14,%rbp,4),%ebx
jb     12ec <BEthresh+0x1dc>
ucomisd %xmm4,%xmm7
ja     1a16 <BEthresh+0x906>
cmp    $0xffffffff,%r12d
je     1a1c <BEthresh+0x90c>
cmp    $0x1,%r15
je     1a25 <BEthresh+0x915>
test   %r12d,%r12d
je     1377 <BEthresh+0x267>
movslq %ebx,%r8
lea    -0x1(%r15),%edi
cmp    %edi,%r12d
mov    %rbx,0x8(%rsp)
jne    160a <BEthresh+0x4fa>
add    $0xffffffff,%r12d
mov    %rbx,%rcx
movslq (%r14,%r12,4),%rbx
mov    %esi,%eax
sub    %ebx,%eax
xorps  %xmm2,%xmm2
cvtsi2sd %eax,%xmm2
mov    %esi,%eax
sub    %ecx,%eax
xorps  %xmm4,%xmm4
cvtsi2sd %eax,%xmm4
movapd %xmm2,%xmm1
divsd  %xmm4,%xmm1
lea    0x1(%rbx),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm1,%xmm0
lea    0x1(%rcx),%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  (%rdx,%rbx,8),%xmm6
divsd  %xmm1,%xmm0
ucomisd %xmm5,%xmm0
jb     1685 <BEthresh+0x575>
sqrtsd %xmm0,%xmm0
jmp    16d2 <BEthresh+0x5c2>
movapd %xmm7,%xmm6
movslq 0x4(%r14),%rbp
mov    %esi,%eax
sub    %ebp,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    %esi,%eax
sub    %ebx,%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  (%rdx,%rbp,8),%xmm2
lea    0x1(%rbp),%eax
xorps  %xmm4,%xmm4
cvtsi2sd %eax,%xmm4
divsd  %xmm1,%xmm0
lea    0x1(%rbx),%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
mulsd  %xmm4,%xmm0
divsd  %xmm1,%xmm0
ucomisd %xmm5,%xmm0
jb     13d0 <BEthresh+0x2c0>
sqrtsd %xmm0,%xmm0
jmp    1413 <BEthresh+0x303>
cs nopw 0x0(%rax,%rax,1)
movsd  %xmm6,0x8(%rsp)
movsd  %xmm2,0x60(%rsp)
movsd  %xmm4,0x50(%rsp)
movsd  %xmm1,0x48(%rsp)
call   1030 <sqrt@plt>
movsd  0x48(%rsp),%xmm1
movsd  0x50(%rsp),%xmm4
movsd  0x60(%rsp),%xmm2
movsd  0x8(%rsp),%xmm6
xorpd  %xmm5,%xmm5
mov    0x20(%rsp),%rsi
mov    0x28(%rsp),%rdx
movsd  0x10(%rsp),%xmm3
mulsd  %xmm1,%xmm0
divsd  %xmm4,%xmm0
movslq %ebx,%rax
mulsd  (%rdx,%rax,8),%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rdx,%rbp,8)
movq   $0x0,(%rdx,%rax,8)
movq   $0x0,0x0(%r13,%rax,8)
movslq 0x4(%r14),%r12
movapd %xmm3,%xmm1
mov    %esi,%eax
cmp    $0x2,%r15
je     1461 <BEthresh+0x351>
mov    0x8(%r14),%eax
lea    0x1(%rax),%ecx
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
mov    %esi,%ecx
sub    %r12d,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
lea    0x1(%r12),%ecx
xorps  %xmm2,%xmm2
cvtsi2sd %ecx,%xmm2
mulsd  %xmm2,%xmm0
divsd  %xmm3,%xmm0
mulsd  %xmm1,%xmm0
sub    %r12d,%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
divsd  %xmm2,%xmm0
movsd  (%rdx,%r12,8),%xmm1
ucomisd %xmm5,%xmm1
jae    14ab <BEthresh+0x39b>
xorpd  0xb65(%rip),%xmm1
xor    %ebp,%ebp
ucomisd %xmm5,%xmm0
jb     14c0 <BEthresh+0x3b0>
sqrtsd %xmm0,%xmm0
jmp    14eb <BEthresh+0x3db>
nopl   0x0(%rax)
movsd  %xmm6,0x8(%rsp)
movapd %xmm1,0x60(%rsp)
call   1030 <sqrt@plt>
movapd 0x60(%rsp),%xmm1
movsd  0x8(%rsp),%xmm6
xorpd  %xmm5,%xmm5
mov    0x20(%rsp),%rsi
mov    0x28(%rsp),%rdx
movsd  0x78(%rsp),%xmm4
mov    0x88(%rsp),%r10
mov    0x80(%rsp),%r11
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%r12,8)
add    $0xffffffffffffffff,%r15
cmp    %rbp,%r15
jle    1190 <BEthresh+0x80>
mov    %r11,%rax
not    %rax
add    0xa0(%rsp),%rax
sub    %rbp,%rax
cmp    $0x8,%rax
jb     15f0 <BEthresh+0x4e0>
mov    %rax,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rcx
mov    %rcx,%r9
shr    $0x3,%r9
add    $0x1,%r9
mov    %rbx,%r12
test   %rcx,%rcx
je     1674 <BEthresh+0x564>
mov    0x98(%rsp),%rcx
lea    (%rcx,%rbp,4),%rbx
mov    %r10,%rdi
sub    %rbp,%rdi
and    $0xfffffffffffffff8,%rdi
add    $0xfffffffffffffff8,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %ecx,%ecx
xchg   %ax,%ax
movupd -0x30(%rbx,%rcx,4),%xmm0
movupd -0x20(%rbx,%rcx,4),%xmm1
movupd -0x10(%rbx,%rcx,4),%xmm2
movupd (%rbx,%rcx,4),%xmm3
movupd %xmm0,-0x34(%rbx,%rcx,4)
movupd %xmm1,-0x24(%rbx,%rcx,4)
movupd %xmm2,-0x14(%rbx,%rcx,4)
movupd %xmm3,-0x4(%rbx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1580 <BEthresh+0x470>
test   $0x1,%r9b
je     15dd <BEthresh+0x4cd>
add    %rbp,%rcx
movupd 0x4(%r14,%rcx,4),%xmm0
movupd 0x14(%r14,%rcx,4),%xmm1
movupd %xmm0,(%r14,%rcx,4)
movupd %xmm1,0x10(%r14,%rcx,4)
cmp    %r8,%rax
mov    %r12,%rbx
je     1190 <BEthresh+0x80>
add    %r8,%rbp
nopl   0x0(%rax)
mov    0x4(%r14,%rbp,4),%eax
mov    %eax,(%r14,%rbp,4)
lea    0x1(%rbp),%rax
mov    %rax,%rbp
cmp    %r15,%rax
jl     15f0 <BEthresh+0x4e0>
jmp    1190 <BEthresh+0x80>
mov    %rbx,%rcx
movslq 0x4(%r14,%rbp,4),%rbx
mov    %esi,%eax
sub    %ebx,%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movslq -0x4(%r14,%rbp,4),%r12
mov    %esi,%eax
sub    %ecx,%eax
xorps  %xmm2,%xmm2
cvtsi2sd %eax,%xmm2
divsd  %xmm2,%xmm1
lea    0x1(%rbx),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm1,%xmm0
lea    0x1(%rcx),%eax
xorps  %xmm3,%xmm3
cvtsi2sd %eax,%xmm3
movsd  (%rdx,%rbx,8),%xmm6
divsd  %xmm3,%xmm0
ucomisd %xmm5,%xmm0
movsd  %xmm7,0x60(%rsp)
mov    %r8,0x50(%rsp)
mov    %edi,0x48(%rsp)
jb     1713 <BEthresh+0x603>
sqrtsd %xmm0,%xmm0
jmp    174f <BEthresh+0x63f>
xor    %ecx,%ecx
test   $0x1,%r9b
jne    15bf <BEthresh+0x4af>
jmp    15dd <BEthresh+0x4cd>
movsd  %xmm7,0x60(%rsp)
mov    %r8,0x50(%rsp)
movsd  %xmm2,0x48(%rsp)
movsd  %xmm4,0x18(%rsp)
movsd  %xmm6,0x30(%rsp)
call   1030 <sqrt@plt>
movsd  0x30(%rsp),%xmm6
movsd  0x18(%rsp),%xmm4
movsd  0x48(%rsp),%xmm2
mov    0x50(%rsp),%r8
movsd  0x60(%rsp),%xmm7
xorpd  %xmm5,%xmm5
mov    0x20(%rsp),%rsi
mov    0x28(%rsp),%rdx
movsd  0x10(%rsp),%xmm3
mulsd  %xmm4,%xmm0
divsd  %xmm2,%xmm0
mulsd  (%rdx,%r8,8),%xmm0
addsd  %xmm6,%xmm0
movsd  %xmm0,(%rdx,%rbx,8)
movq   $0x0,(%rdx,%r8,8)
movq   $0x0,0x0(%r13,%r8,8)
test   %r12,%r12
je     191d <BEthresh+0x80d>
mov    -0x8(%r14,%rbp,4),%eax
jmp    1922 <BEthresh+0x812>
movsd  %xmm2,0x18(%rsp)
movsd  %xmm3,0x30(%rsp)
movsd  %xmm6,0x70(%rsp)
call   1030 <sqrt@plt>
movsd  0x70(%rsp),%xmm6
movsd  0x30(%rsp),%xmm3
movsd  0x18(%rsp),%xmm2
mov    0x50(%rsp),%r8
xorpd  %xmm5,%xmm5
mov    0x20(%rsp),%rsi
mov    0x28(%rsp),%rdx
lea    0x1(%rbp),%r10
lea    -0x1(%rbp),%r9
mov    0x8(%rsp),%rax
sub    %r12d,%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
mulsd  %xmm0,%xmm1
mov    %ebx,%eax
sub    %r12d,%eax
cvtsi2sd %eax,%xmm4
divsd  %xmm4,%xmm1
mulsd  (%rdx,%r8,8),%xmm1
addsd  %xmm6,%xmm1
movsd  %xmm1,(%rdx,%rbx,8)
movsd  (%rdx,%r12,8),%xmm6
mov    %esi,%eax
sub    %r12d,%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
divsd  %xmm2,%xmm1
lea    0x1(%r12),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm1,%xmm0
divsd  %xmm3,%xmm0
ucomisd %xmm5,%xmm0
mov    %r10,0x18(%rsp)
jb     17c1 <BEthresh+0x6b1>
sqrtsd %xmm0,%xmm0
jmp    1806 <BEthresh+0x6f6>
mov    %r9,0x30(%rsp)
movsd  %xmm4,0x70(%rsp)
movsd  %xmm6,0x90(%rsp)
call   1030 <sqrt@plt>
movsd  0x90(%rsp),%xmm6
movsd  0x70(%rsp),%xmm4
mov    0x30(%rsp),%r9
mov    0x18(%rsp),%r10
mov    0x50(%rsp),%r8
xorpd  %xmm5,%xmm5
mov    0x20(%rsp),%rsi
mov    0x28(%rsp),%rdx
movsd  0x10(%rsp),%xmm3
sub    0x8(%rsp),%ebx
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
mulsd  %xmm0,%xmm1
divsd  %xmm4,%xmm1
mulsd  (%rdx,%r8,8),%xmm1
addsd  %xmm6,%xmm1
movsd  %xmm1,(%rdx,%r12,8)
movq   $0x0,(%rdx,%r8,8)
movq   $0x0,0x0(%r13,%r8,8)
mov    (%r14,%r9,4),%eax
movslq (%r14,%r10,4),%rbx
mov    %esi,%ecx
cmp    0x48(%rsp),%r10d
je     1856 <BEthresh+0x746>
mov    0x8(%r14,%rbp,4),%ecx
mov    %esi,%edi
sub    %ebx,%edi
xorps  %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
lea    0x1(%rbx),%edi
xorps  %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
mulsd  %xmm0,%xmm1
divsd  %xmm3,%xmm1
mov    %ecx,%edi
sub    %eax,%edi
xorps  %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
mulsd  %xmm1,%xmm0
sub    %ebx,%ecx
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
divsd  %xmm1,%xmm0
mov    %ebx,%ecx
sub    %eax,%ecx
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
divsd  %xmm1,%xmm0
movsd  (%rdx,%rbx,8),%xmm4
ucomisd %xmm5,%xmm0
jb     18af <BEthresh+0x79f>
sqrtsd %xmm0,%xmm0
jmp    18df <BEthresh+0x7cf>
mov    %r9,%r12
movapd %xmm4,0x50(%rsp)
call   1030 <sqrt@plt>
movapd 0x50(%rsp),%xmm4
mov    %r12,%r9
mov    0x18(%rsp),%r10
xorpd  %xmm5,%xmm5
movsd  0x10(%rsp),%xmm3
mov    0x20(%rsp),%rsi
mov    0x28(%rsp),%rdx
movsd  0x60(%rsp),%xmm6
movapd %xmm4,%xmm1
xorpd  0x71f(%rip),%xmm1
xorpd  %xmm2,%xmm2
cmpnlesd %xmm4,%xmm2
andpd  %xmm2,%xmm1
andnpd %xmm4,%xmm2
orpd   %xmm1,%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,0x0(%r13,%rbx,8)
test   %r9d,%r9d
je     198b <BEthresh+0x87b>
mov    -0x8(%r14,%rbp,4),%eax
jmp    1990 <BEthresh+0x880>
mov    $0xffffffff,%eax
mov    0x8(%rsp),%rbx
movslq (%r14,%r12,4),%r12
mov    %esi,%ecx
sub    %r12d,%ecx
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
lea    0x1(%r12),%ecx
xorps  %xmm2,%xmm2
cvtsi2sd %ecx,%xmm2
mulsd  %xmm1,%xmm2
divsd  %xmm3,%xmm2
mov    %esi,%ecx
sub    %eax,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
mulsd  %xmm2,%xmm0
divsd  %xmm1,%xmm0
mov    %r12d,%ecx
sub    %eax,%ecx
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
divsd  %xmm1,%xmm0
movsd  (%rdx,%r12,8),%xmm1
ucomisd %xmm5,%xmm1
jae    1982 <BEthresh+0x872>
xorpd  0x68e(%rip),%xmm1
movapd %xmm7,%xmm6
jmp    14ad <BEthresh+0x39d>
mov    $0xffffffff,%eax
mov    0x8(%rsp),%rbx
movslq (%r14,%r9,4),%r12
mov    (%r14,%r10,4),%ecx
mov    %esi,%edi
sub    %r12d,%edi
xorps  %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
lea    0x1(%r12),%edi
xorps  %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
mulsd  %xmm0,%xmm1
divsd  %xmm3,%xmm1
mov    %ecx,%edi
sub    %eax,%edi
xorps  %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
mulsd  %xmm1,%xmm0
sub    %r12d,%ecx
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
divsd  %xmm1,%xmm0
mov    %r12d,%ecx
sub    %eax,%ecx
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
divsd  %xmm1,%xmm0
movsd  (%rdx,%r12,8),%xmm1
ucomisd %xmm5,%xmm1
jae    14ad <BEthresh+0x39d>
xorpd  0x60e(%rip),%xmm1
jmp    14ad <BEthresh+0x39d>
movsd  0x5f1(%rip),%xmm6
mov    $0xffffffff,%ebx
jmp    1a4a <BEthresh+0x93a>
movapd %xmm7,%xmm6
jmp    1a40 <BEthresh+0x930>
xor    %r15d,%r15d
xorpd  %xmm6,%xmm6
jmp    1a40 <BEthresh+0x930>
movapd %xmm7,%xmm6
movslq %ebx,%rax
movq   $0x0,0x0(%r13,%rax,8)
movq   $0x0,(%rdx,%rax,8)
xor    %r15d,%r15d
mov    0x40(%rsp),%r8
mov    0x38(%rsp),%r9
movsd  %xmm6,(%r9)
mov    %r15d,(%r8)
mov    %ebx,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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