#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 fabs(double);
double fmax(double, double);
double fmin(double, double);
int log(int);
int odrrb_(int *n, double *d__, double *lld, int *ifirst, int *ilast,
           double *rtol1, double *rtol2, int *offset, double *w, double *wgap,
           double *werr, double *work, int *iwork, double *pivmin,
           double *spdiam, int *twist, int *info) {
  int i__1;
  double d__1, d__2;
  int i__, k, r__, i1, ii, ip;
  double gap, mid, tmp, back, lgap, rgap, left;
  int iter, nint, prev, next;
  double cvrgd, right, width;
  extern int odneg_(int *, double *, double *, double *, double *, int *);
  int negcnt;
  double mnwdth;
  int olnint, maxitr;
  --iwork;
  --work;
  --werr;
  --wgap;
  --w;
  --lld;
  --d__;
  *info = 0;
  maxitr = (int)((log(*spdiam + *pivmin) - log(*pivmin)) / log(2.)) + 2;
  mnwdth = *pivmin * 2.;
  r__ = *twist;
  if (r__ < 1 || r__ > *n) {
    r__ = *n;
  }
  i1 = *ifirst;
  nint = 0;
  prev = 0;
  rgap = wgap[i1 - *offset];
  i__1 = *ilast;
  for (i__ = i1; i__ <= i__1; ++i__) {
    k = i__ << 1;
    ii = i__ - *offset;
    left = w[ii] - werr[ii];
    right = w[ii] + werr[ii];
    lgap = rgap;
    rgap = wgap[ii];
    gap = fmin(lgap, rgap);
    back = werr[ii];
  L20:
    negcnt = odneg_(n, &d__[1], &lld[1], &left, pivmin, &r__);
    if (negcnt > i__ - 1) {
      left -= back;
      back *= 2.;
      goto L20;
    }
    back = werr[ii];
  L50:
    negcnt = odneg_(n, &d__[1], &lld[1], &right, pivmin, &r__);
    if (negcnt < i__) {
      right += back;
      back *= 2.;
      goto L50;
    }
    width = (d__1 = left - right, fabs(d__1)) * .5;
    d__1 = fabs(left), d__2 = fabs(right);
    tmp = fmax(d__1, d__2);
    d__1 = *rtol1 * gap, d__2 = *rtol2 * tmp;
    cvrgd = fmax(d__1, d__2);
    if (width <= cvrgd || width <= mnwdth) {
      iwork[k - 1] = -1;
      if (i__ == i1 && i__ < *ilast) {
        i1 = i__ + 1;
      }
      if (prev >= i1 && i__ <= *ilast) {
        iwork[(prev << 1) - 1] = i__ + 1;
      }
    } else {
      prev = i__;
      ++nint;
      iwork[k - 1] = i__ + 1;
      iwork[k] = negcnt;
    }
    work[k - 1] = left;
    work[k] = right;
  }
  iter = 0;
L80:
  prev = i1 - 1;
  i__ = i1;
  olnint = nint;
  i__1 = olnint;
  for (ip = 1; ip <= i__1; ++ip) {
    k = i__ << 1;
    ii = i__ - *offset;
    rgap = wgap[ii];
    lgap = rgap;
    if (ii > 1) {
      lgap = wgap[ii - 1];
    }
    gap = fmin(lgap, rgap);
    next = iwork[k - 1];
    left = work[k - 1];
    right = work[k];
    mid = (left + right) * .5;
    width = right - mid;
    d__1 = fabs(left), d__2 = fabs(right);
    tmp = fmax(d__1, d__2);
    d__1 = *rtol1 * gap, d__2 = *rtol2 * tmp;
    cvrgd = fmax(d__1, d__2);
    if (width <= cvrgd || width <= mnwdth || iter == maxitr) {
      --nint;
      iwork[k - 1] = 0;
      if (i1 == i__) {
        i1 = next;
      } else {
        if (prev >= i1) {
          iwork[(prev << 1) - 1] = next;
        }
      }
      i__ = next;
      goto L100;
    }
    prev = i__;
    negcnt = odneg_(n, &d__[1], &lld[1], &mid, pivmin, &r__);
    if (negcnt <= i__ - 1) {
      work[k - 1] = mid;
    } else {
      work[k] = mid;
    }
    i__ = next;
  L100:;
  }
  ++iter;
  if (nint > 0 && iter <= maxitr) {
    goto L80;
  }
  i__1 = *ilast;
  for (i__ = *ifirst; i__ <= i__1; ++i__) {
    k = i__ << 1;
    ii = i__ - *offset;
    if (iwork[k - 1] == 0) {
      w[ii] = (work[k - 1] + work[k]) * .5;
      werr[ii] = work[k] - w[ii];
    }
  }
  i__1 = *ilast;
  for (i__ = *ifirst + 1; i__ <= i__1; ++i__) {
    k = i__ << 1;
    ii = i__ - *offset;
    d__1 = 0., d__2 = w[ii] - werr[ii] - w[ii - 1] - werr[ii - 1];
    wgap[ii - 1] = fmax(d__1, d__2);
  }
  return 0;
}


x86 assembly (clang, -O0):
<odrrb_>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    0x40(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x40(%rbp)
mov    0x38(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x38(%rbp)
mov    0x30(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x30(%rbp)
mov    0x28(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x28(%rbp)
mov    0x20(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x20(%rbp)
mov    -0x18(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x10(%rbp)
mov    0x60(%rbp),%rax
movl   $0x0,(%rax)
mov    0x50(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x48(%rbp),%rax
addsd  (%rax),%xmm0
cvttsd2si %xmm0,%edi
call   1030 <log@plt>
mov    %eax,-0xe0(%rbp)
mov    0x48(%rbp),%rax
cvttsd2si (%rax),%edi
call   1030 <log@plt>
mov    %eax,%ecx
mov    -0xe0(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xdc(%rbp)
mov    $0x2,%edi
call   1030 <log@plt>
mov    %eax,%ecx
mov    -0xdc(%rbp),%eax
cltd
idiv   %ecx
add    $0x2,%eax
mov    %eax,-0xd8(%rbp)
mov    0x48(%rbp),%rax
movsd  0xdcd(%rip),%xmm0
mulsd  (%rax),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    0x58(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x54(%rbp)
cmpl   $0x1,-0x54(%rbp)
jl     1261 <odrrb_+0x141>
mov    -0x54(%rbp),%eax
mov    -0x8(%rbp),%rcx
cmp    (%rcx),%eax
jle    126a <odrrb_+0x14a>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x54(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0xa0(%rbp)
movl   $0x0,-0xa4(%rbp)
mov    0x28(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    0x18(%rbp),%rdx
sub    (%rdx),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1680 <odrrb_+0x560>
mov    -0x4c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    0x18(%rbp),%rcx
sub    (%rcx),%eax
mov    %eax,-0x5c(%rbp)
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x5c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x28(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x88(%rbp),%xmm3
ff
movsd  -0x90(%rbp),%xmm2
ff
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
minsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    0x30(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
add    $0x8,%rsi
mov    -0x18(%rbp),%rdx
add    $0x8,%rdx
mov    0x48(%rbp),%r8
lea    -0x98(%rbp),%rcx
lea    -0x54(%rbp),%r9
call   1040 <odneg_@plt>
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    13f4 <odrrb_+0x2d4>
movsd  -0x80(%rbp),%xmm1
movsd  -0x98(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0xc1b(%rip),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    1382 <odrrb_+0x262>
mov    0x30(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
add    $0x8,%rsi
mov    -0x18(%rbp),%rdx
add    $0x8,%rdx
mov    0x48(%rbp),%r8
lea    -0xb8(%rbp),%rcx
lea    -0x54(%rbp),%r9
call   1040 <odneg_@plt>
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    146f <odrrb_+0x34f>
movsd  -0x80(%rbp),%xmm0
addsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  0xba0(%rip),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    1406 <odrrb_+0x2e6>
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
movaps 0xb80(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xb6c(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movaps 0xb59(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0xb8(%rbp),%xmm0
ff
movaps 0xb41(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm3
movsd  -0x48(%rbp),%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
maxsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm3
movsd  -0x48(%rbp),%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
maxsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jae    158d <odrrb_+0x46d>
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0xd0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     1604 <odrrb_+0x4e4>
mov    0x40(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
cmp    -0x58(%rbp),%eax
jne    15c5 <odrrb_+0x4a5>
mov    -0x4c(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    (%rcx),%eax
jge    15c5 <odrrb_+0x4a5>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x58(%rbp),%eax
jl     15ff <odrrb_+0x4df>
mov    -0x4c(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    (%rcx),%eax
jg     15ff <odrrb_+0x4df>
mov    -0x4c(%rbp),%edx
add    $0x1,%edx
mov    0x40(%rbp),%rax
mov    -0xa4(%rbp),%ecx
shl    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1643 <odrrb_+0x523>
mov    -0x4c(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x4c(%rbp),%edx
add    $0x1,%edx
mov    0x40(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xc4(%rbp),%edx
mov    0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movsd  -0x98(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12b3 <odrrb_+0x193>
movl   $0x0,-0x9c(%rbp)
mov    -0x58(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0xa0(%rbp),%eax
mov    %eax,-0xd4(%rbp)
mov    -0xd4(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     19d4 <odrrb_+0x8b4>
mov    -0x4c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    0x18(%rbp),%rcx
sub    (%rcx),%eax
mov    %eax,-0x5c(%rbp)
mov    0x28(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x1,-0x5c(%rbp)
jle    1722 <odrrb_+0x602>
mov    0x28(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm3
ff
movsd  -0x90(%rbp),%xmm2
ff
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
minsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    0x40(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xa8(%rbp)
mov    0x38(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    0x38(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
movsd  0x856(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0xb8(%rbp),%xmm0
ff
subsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movaps 0x831(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0xb8(%rbp),%xmm0
ff
movaps 0x819(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm3
movsd  -0x48(%rbp),%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
maxsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm3
movsd  -0x48(%rbp),%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
maxsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jae    18c7 <odrrb_+0x7a7>
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0xd0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jae    18c7 <odrrb_+0x7a7>
mov    -0x9c(%rbp),%eax
cmp    -0xd8(%rbp),%eax
jne    1942 <odrrb_+0x822>
mov    -0xa0(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xa0(%rbp)
mov    0x40(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jne    1904 <odrrb_+0x7e4>
mov    -0xa8(%rbp),%eax
mov    %eax,-0x58(%rbp)
jmp    1934 <odrrb_+0x814>
mov    -0xa4(%rbp),%eax
cmp    -0x58(%rbp),%eax
jl     192f <odrrb_+0x80f>
mov    -0xa8(%rbp),%edx
mov    0x40(%rbp),%rax
mov    -0xa4(%rbp),%ecx
shl    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1934 <odrrb_+0x814>
mov    -0xa8(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    19c1 <odrrb_+0x8a1>
mov    -0x4c(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
add    $0x8,%rsi
mov    -0x18(%rbp),%rdx
add    $0x8,%rdx
mov    0x48(%rbp),%r8
lea    -0x70(%rbp),%rcx
lea    -0x54(%rbp),%r9
call   1040 <odneg_@plt>
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     19a6 <odrrb_+0x886>
movsd  -0x70(%rbp),%xmm0
mov    0x38(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    19b8 <odrrb_+0x898>
movsd  -0x70(%rbp),%xmm0
mov    0x38(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    19c6 <odrrb_+0x8a6>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    16b8 <odrrb_+0x598>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
cmpl   $0x0,-0xa0(%rbp)
jle    1a07 <odrrb_+0x8e7>
mov    -0x9c(%rbp),%eax
cmp    -0xd8(%rbp),%eax
jg     1a07 <odrrb_+0x8e7>
jmp    168a <odrrb_+0x56a>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1ac3 <odrrb_+0x9a3>
mov    -0x4c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    0x18(%rbp),%rcx
sub    (%rcx),%eax
mov    %eax,-0x5c(%rbp)
mov    0x40(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1ab0 <odrrb_+0x990>
mov    0x38(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x50(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x590(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ab5 <odrrb_+0x995>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1a19 <odrrb_+0x8f9>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1b8c <odrrb_+0xa6c>
mov    -0x4c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    0x18(%rbp),%rcx
sub    (%rcx),%eax
mov    %eax,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm3
movsd  -0x48(%rbp),%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
maxsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
mov    0x28(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1ad8 <odrrb_+0x9b8>
xor    %eax,%eax
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<odrrb_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r9,0x78(%rsp)
mov    %r8,%r12
mov    %rcx,%r14
mov    %rdx,0x20(%rsp)
mov    %rsi,0x18(%rsp)
mov    %rdi,%rbp
mov    0x128(%rsp),%r15
mov    0xf8(%rsp),%r13
mov    0x140(%rsp),%rax
movl   $0x0,(%rax)
mov    0x130(%rsp),%rax
movsd  (%rax),%xmm0
addsd  (%r15),%xmm0
cvttsd2si %xmm0,%edi
call   1030 <log@plt>
mov    %eax,%ebx
cvttsd2si (%r15),%edi
call   1030 <log@plt>
sub    %eax,%ebx
mov    $0x2,%edi
call   1030 <log@plt>
mov    %eax,%ecx
mov    %ebx,%eax
cltd
idiv   %ecx
mov    %eax,0xc(%rsp)
movsd  (%r15),%xmm0
addsd  %xmm0,%xmm0
movsd  %xmm0,0x70(%rsp)
mov    0x138(%rsp),%rax
mov    (%rax),%eax
mov    %eax,0x8(%rsp)
mov    %rbp,0x30(%rsp)
mov    0x0(%rbp),%ecx
cmp    %ecx,%eax
mov    %eax,%edx
cmovg  %ecx,%edx
test   %eax,%eax
cmovle %ecx,%edx
mov    %edx,0x8(%rsp)
mov    %r14,0x88(%rsp)
mov    (%r14),%r8d
mov    %r12,0x40(%rsp)
mov    (%r12),%edx
xor    %eax,%eax
mov    %rax,0x60(%rsp)
cmp    %edx,%r8d
jle    121b <odrrb_+0xfb>
xor    %edi,%edi
mov    0x108(%rsp),%r11
mov    %r13,%r15
mov    0x120(%rsp),%r9
mov    0x118(%rsp),%r10
jmp    15c1 <odrrb_+0x4a1>
movslq %r8d,%r15
mov    0x0(%r13),%eax
mov    %r8,0x50(%rsp)
mov    %r8d,%ecx
sub    %eax,%ecx
movslq %ecx,%rcx
mov    0x108(%rsp),%r11
movsd  -0x8(%r11,%rcx,8),%xmm0
movapd %xmm0,0x90(%rsp)
add    $0x1,%edx
mov    %edx,0x6c(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x48(%rsp)
lea    0x10(%rsp),%rbx
lea    0x8(%rsp),%rbp
movl   $0x0,0x4(%rsp)
mov    0x20(%rsp),%r12
mov    0x18(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x128(%rsp),%r14
cltq
mov    %r15,%rdx
sub    %rax,%rdx
mov    0x100(%rsp),%rax
movsd  -0x8(%rax,%rdx,8),%xmm0
mov    0x110(%rsp),%rax
movsd  -0x8(%rax,%rdx,8),%xmm2
movapd %xmm0,%xmm1
subsd  %xmm2,%xmm1
movsd  %xmm1,0x10(%rsp)
movsd  %xmm2,0x28(%rsp)
addsd  %xmm2,%xmm0
movsd  %xmm0,0x38(%rsp)
mov    %rdx,0x58(%rsp)
movsd  -0x8(%r11,%rdx,8),%xmm0
movaps %xmm0,0xa0(%rsp)
xchg   %ax,%ax
mov    0x30(%rsp),%rdi
mov    %r13,%rsi
mov    %r12,%rdx
mov    %rbx,%rcx
mov    %r14,%r8
mov    %rbp,%r9
call   1040 <odneg_@plt>
cltq
cmp    %rax,%r15
jg     1330 <odrrb_+0x210>
movsd  0x10(%rsp),%xmm0
movsd  0x28(%rsp),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rsp)
addsd  %xmm1,%xmm1
movsd  %xmm1,0x28(%rsp)
jmp    12e0 <odrrb_+0x1c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r15,%r15,1),%ebx
mov    0x110(%rsp),%rax
mov    0x58(%rsp),%rcx
movsd  -0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x28(%rsp)
mov    0x30(%rsp),%rdi
mov    %r13,%rsi
mov    %r12,%rdx
lea    0x38(%rsp),%r13
mov    %r13,%rcx
mov    %r14,%r8
mov    %rbp,%r9
call   1040 <odneg_@plt>
movslq %eax,%rcx
cmp    %rcx,%r15
jle    13d5 <odrrb_+0x2b5>
mov    %ebx,0x58(%rsp)
mov    0x20(%rsp),%r14
lea    0x8(%rsp),%rbx
mov    0x18(%rsp),%r12
mov    0x128(%rsp),%rbp
xchg   %ax,%ax
movsd  0x38(%rsp),%xmm0
movsd  0x28(%rsp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,0x38(%rsp)
addsd  %xmm1,%xmm1
movsd  %xmm1,0x28(%rsp)
mov    0x30(%rsp),%rdi
mov    %r12,%rsi
mov    %r14,%rdx
mov    %r13,%rcx
mov    %rbp,%r8
mov    %rbx,%r9
call   1040 <odneg_@plt>
movslq %eax,%rcx
cmp    %rcx,%r15
jg     1390 <odrrb_+0x270>
mov    0x58(%rsp),%ebx
movapd 0xa0(%rsp),%xmm8
movapd %xmm8,%xmm0
movapd 0x90(%rsp),%xmm1
minsd  %xmm1,%xmm0
cmpunordsd %xmm1,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm8,%xmm2
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
movsd  0x10(%rsp),%xmm0
movsd  0x38(%rsp),%xmm7
movapd %xmm0,%xmm2
subsd  %xmm7,%xmm2
movapd 0xbdd(%rip),%xmm5
andpd  %xmm5,%xmm2
mulsd  0xbe1(%rip),%xmm2
movapd %xmm0,%xmm3
andpd  %xmm5,%xmm3
movapd %xmm7,%xmm4
andpd  %xmm5,%xmm4
movapd %xmm3,%xmm5
cmpunordsd %xmm3,%xmm5
movapd %xmm5,%xmm6
andpd  %xmm4,%xmm6
maxsd  %xmm3,%xmm4
andnpd %xmm4,%xmm5
orpd   %xmm6,%xmm5
mov    0x78(%rsp),%rcx
mulsd  (%rcx),%xmm1
mov    0xf0(%rsp),%rcx
mulsd  (%rcx),%xmm5
movapd %xmm1,%xmm3
cmpunordsd %xmm1,%xmm3
movapd %xmm3,%xmm4
andpd  %xmm5,%xmm4
maxsd  %xmm1,%xmm5
andnpd %xmm5,%xmm3
orpd   %xmm4,%xmm3
ucomisd %xmm2,%xmm3
movslq %ebx,%rcx
jae    1500 <odrrb_+0x3e0>
movsd  0x70(%rsp),%xmm3
ucomisd %xmm2,%xmm3
jae    1500 <odrrb_+0x3e0>
addl   $0x1,0x4(%rsp)
lea    -0x1(%rcx),%rdx
lea    0x1(%r15),%esi
mov    0x120(%rsp),%r9
mov    %esi,-0x8(%r9,%rcx,4)
mov    %eax,-0x4(%r9,%rcx,4)
mov    %r15d,%eax
mov    %rax,0x48(%rsp)
mov    0x108(%rsp),%r11
mov    0xf8(%rsp),%rbp
mov    0x118(%rsp),%r10
mov    0x20(%rsp),%r12
mov    0x50(%rsp),%r8
mov    0x18(%rsp),%r13
jmp    1580 <odrrb_+0x460>
cs nopw 0x0(%rax,%rax,1)
mov    0x120(%rsp),%r9
movl   $0xffffffff,-0x8(%r9,%rcx,4)
ff ff
mov    0x50(%rsp),%r8
cmp    %r15d,%r8d
mov    0x108(%rsp),%r11
mov    0xf8(%rsp),%rbp
mov    0x118(%rsp),%r10
mov    0x20(%rsp),%r12
mov    0x18(%rsp),%r13
jne    1550 <odrrb_+0x430>
mov    0x40(%rsp),%rax
movslq (%rax),%rax
lea    0x1(%r15),%edx
cmp    %rax,%r15
cmovl  %edx,%r8d
lea    -0x1(%rcx),%rdx
cmp    %r8d,0x48(%rsp)
jl     1580 <odrrb_+0x460>
mov    0x40(%rsp),%rax
movslq (%rax),%rax
cmp    %rax,%r15
jg     1580 <odrrb_+0x460>
mov    0x48(%rsp),%rax
add    %eax,%eax
cltq
lea    0x1(%r15),%esi
mov    %esi,-0x8(%r9,%rax,4)
nopw   0x0(%rax,%rax,1)
movsd  %xmm0,-0x8(%r10,%rdx,8)
movsd  %xmm7,-0x8(%r10,%rcx,8)
add    $0x1,%r15
cmp    %r15d,0x6c(%rsp)
je     15ba <odrrb_+0x49a>
mov    %r8,0x50(%rsp)
mov    0x0(%rbp),%eax
movapd %xmm8,0x90(%rsp)
lea    0x10(%rsp),%rbx
lea    0x8(%rsp),%rbp
jmp    1280 <odrrb_+0x160>
mov    0x4(%rsp),%edi
mov    %rbp,%r15
addl   $0x2,0xc(%rsp)
movsd  0xa41(%rip),%xmm8
movapd 0xa29(%rip),%xmm7
nopw   0x0(%rax,%rax,1)
test   %edi,%edi
jle    17fb <odrrb_+0x6db>
lea    -0x1(%r8),%eax
mov    %edi,%ebx
mov    %r8d,%r14d
jmp    1645 <odrrb_+0x525>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  %xmm0,-0x8(%r10,%r13,8)
mov    %ebp,%eax
mov    0x108(%rsp),%r11
mov    0xf8(%rsp),%rdi
mov    0x120(%rsp),%r9
mov    %r15,%r8
mov    %rdi,%r15
mov    0x4(%rsp),%edi
movsd  0x9dc(%rip),%xmm8
movapd 0x9c4(%rip),%xmm7
add    $0xffffffff,%ebx
je     17e0 <odrrb_+0x6c0>
mov    %r14d,%ebp
lea    0x0(%rbp,%rbp,1),%ecx
movslq (%r15),%rsi
movslq %r14d,%rdx
sub    %rsi,%rdx
movsd  -0x8(%r11,%rdx,8),%xmm1
movapd %xmm1,%xmm2
cmp    $0x2,%edx
jl     166f <odrrb_+0x54f>
add    $0xffffffff,%edx
movsd  -0x8(%r11,%rdx,8),%xmm2
movapd %xmm2,%xmm0
cmpunordsd %xmm2,%xmm0
movapd %xmm0,%xmm3
andpd  %xmm1,%xmm3
minsd  %xmm2,%xmm1
andnpd %xmm1,%xmm0
orpd   %xmm3,%xmm0
movslq %ecx,%r13
mov    -0x8(%r9,%r13,4),%r14d
movsd  -0x10(%r10,%r13,8),%xmm2
movsd  %xmm2,0x10(%rsp)
movsd  -0x8(%r10,%r13,8),%xmm3
movsd  %xmm3,0x38(%rsp)
movapd %xmm2,%xmm4
addsd  %xmm3,%xmm4
movapd %xmm3,%xmm1
andpd  %xmm7,%xmm2
andpd  %xmm7,%xmm3
movapd %xmm2,%xmm5
cmpunordsd %xmm2,%xmm5
movapd %xmm5,%xmm6
andpd  %xmm3,%xmm6
maxsd  %xmm2,%xmm3
lea    -0x1(%r13),%r12
mulsd  %xmm8,%xmm4
movsd  %xmm4,0x80(%rsp)
andnpd %xmm3,%xmm5
orpd   %xmm6,%xmm5
mov    0x78(%rsp),%rcx
mulsd  (%rcx),%xmm0
mov    0xf0(%rsp),%rcx
mulsd  (%rcx),%xmm5
subsd  %xmm4,%xmm1
movapd %xmm0,%xmm2
cmpunordsd %xmm0,%xmm2
movapd %xmm2,%xmm3
andpd  %xmm5,%xmm3
maxsd  %xmm0,%xmm5
andnpd %xmm5,%xmm2
orpd   %xmm3,%xmm2
ucomisd %xmm1,%xmm2
jae    17a0 <odrrb_+0x680>
movsd  0x70(%rsp),%xmm0
ucomisd %xmm1,%xmm0
jae    17a0 <odrrb_+0x680>
mov    0x60(%rsp),%rcx
cmp    0xc(%rsp),%ecx
je     17a0 <odrrb_+0x680>
mov    %edi,0x4(%rsp)
mov    0x30(%rsp),%rdi
mov    %r8,%r15
mov    0x18(%rsp),%rsi
mov    0x20(%rsp),%rdx
lea    0x80(%rsp),%rcx
mov    0x128(%rsp),%r8
lea    0x8(%rsp),%r9
call   1040 <odneg_@plt>
movsd  0x80(%rsp),%xmm0
mov    0x118(%rsp),%r10
cmp    %ebp,%eax
jge    1600 <odrrb_+0x4e0>
movsd  %xmm0,-0x8(%r10,%r12,8)
jmp    1607 <odrrb_+0x4e7>
nopl   0x0(%rax)
add    $0xffffffff,%edi
movl   $0x0,-0x4(%r9,%r12,4)
cmp    %ebp,%r8d
jne    17c0 <odrrb_+0x6a0>
mov    %r14d,%r8d
jmp    163c <odrrb_+0x51c>
nopl   0x0(%rax)
cmp    %r8d,%eax
jl     163c <odrrb_+0x51c>
lea    (%rax,%rax,1),%ecx
movslq %ecx,%rcx
mov    %r14d,-0x8(%r9,%rcx,4)
jmp    163c <odrrb_+0x51c>
nopl   0x0(%rax)
test   %edi,%edi
jle    17fb <odrrb_+0x6db>
mov    0x60(%rsp),%rcx
lea    0x1(%rcx),%eax
cmp    0xc(%rsp),%ecx
mov    %rax,0x60(%rsp)
jl     15e0 <odrrb_+0x4c0>
mov    %r15,%rdi
mov    0x40(%rsp),%rax
movslq (%rax),%r12
mov    0x88(%rsp),%rax
movslq (%rax),%r15
cmp    %r12d,%r15d
mov    0x110(%rsp),%r14
jle    1850 <odrrb_+0x730>
cmp    %r12d,%r15d
mov    0x100(%rsp),%rbp
jge    1a6e <odrrb_+0x94e>
movslq (%rdi),%r10
mov    %r12,%r9
sub    %r15,%r9
mov    %r10,%r8
not    %r8
cmp    $0x4,%r9
jae    18dc <odrrb_+0x7bc>
mov    %r15,%rdi
jmp    1a26 <odrrb_+0x906>
mov    0x100(%rsp),%rax
lea    (%rax,%r15,8),%rax
add    $0xfffffffffffffff8,%rax
lea    (%r14,%r15,8),%rsi
add    $0xfffffffffffffff8,%rsi
lea    (%r15,%r15,1),%ecx
mov    %r12d,%ebp
sub    %r15d,%ebp
add    $0x1,%ebp
jmp    1890 <odrrb_+0x770>
nopw   0x0(%rax,%rax,1)
add    $0x8,%rax
add    $0x8,%rsi
add    $0x2,%ecx
add    $0xffffffff,%ebp
je     181e <odrrb_+0x6fe>
lea    -0x1(%rcx),%ebx
movslq %ebx,%rbx
cmpl   $0x0,-0x4(%r9,%rbx,4)
jne    1880 <odrrb_+0x760>
movslq (%rdi),%r8
movsd  -0x8(%r10,%rbx,8),%xmm0
movslq %ecx,%rbx
addsd  -0x8(%r10,%rbx,8),%xmm0
mulsd  %xmm8,%xmm0
shl    $0x3,%r8
mov    %rax,%rdx
sub    %r8,%rdx
movsd  %xmm0,(%rdx)
movsd  -0x8(%r10,%rbx,8),%xmm1
subsd  %xmm0,%xmm1
mov    %rsi,%rdx
sub    %r8,%rdx
movsd  %xmm1,(%rdx)
jmp    1880 <odrrb_+0x760>
lea    (%r8,%r15,1),%rdx
lea    (%r11,%rdx,8),%rsi
lea    (%r8,%r12,1),%rdi
lea    (%r11,%rdi,8),%rdi
lea    0x0(,%rdx,8),%r11
add    %rbp,%r11
mov    %r12,%rbx
sub    %r10,%rbx
lea    0x0(%rbp,%rbx,8),%rbp
mov    %r14,%rax
lea    (%r14,%rdx,8),%r14
lea    (%rax,%rbx,8),%rdx
cmp    %rbp,%rsi
setb   %bpl
cmp    %rdi,%r11
setb   %bl
cmp    %rdx,%rsi
setb   %dl
cmp    %rdi,%r14
setb   %sil
test   %bl,%bpl
jne    1a0b <odrrb_+0x8eb>
and    %sil,%dl
jne    1a0b <odrrb_+0x8eb>
mov    %r9,%rbp
and    $0xfffffffffffffffc,%rbp
lea    (%r15,%rbp,1),%rdi
sub    %r10,%r15
mov    0x108(%rsp),%r11
lea    (%r11,%r15,8),%rsi
add    $0x8,%rsi
mov    0x110(%rsp),%r14
lea    (%r14,%r15,8),%rbx
mov    0x100(%rsp),%rax
lea    (%rax,%r15,8),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x8(%rcx,%rdx,8),%xmm0
movupd (%rcx,%rdx,8),%xmm1
movupd 0x8(%rcx,%rdx,8),%xmm2
movupd 0x10(%rcx,%rdx,8),%xmm3
movupd -0x8(%rbx,%rdx,8),%xmm4
movupd (%rbx,%rdx,8),%xmm5
subpd  %xmm5,%xmm1
subpd  %xmm0,%xmm1
subpd  %xmm4,%xmm1
movupd 0x8(%rbx,%rdx,8),%xmm0
movupd 0x10(%rbx,%rdx,8),%xmm4
subpd  %xmm4,%xmm3
subpd  %xmm2,%xmm3
subpd  %xmm0,%xmm3
xorpd  %xmm0,%xmm0
maxpd  %xmm1,%xmm0
cmpordpd %xmm1,%xmm1
andpd  %xmm0,%xmm1
xorpd  %xmm0,%xmm0
maxpd  %xmm3,%xmm0
cmpordpd %xmm3,%xmm3
andpd  %xmm0,%xmm3
movupd %xmm1,-0x10(%rsi,%rdx,8)
movupd %xmm3,(%rsi,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rbp
jne    1980 <odrrb_+0x860>
cmp    %rbp,%r9
mov    0x100(%rsp),%rbp
jne    1a26 <odrrb_+0x906>
jmp    1a6e <odrrb_+0x94e>
mov    %r15,%rdi
mov    0x110(%rsp),%r14
mov    0x100(%rsp),%rbp
mov    0x108(%rsp),%r11
shl    $0x3,%r10
sub    %r10,%rbp
sub    %r10,%r14
lea    (%r11,%r8,8),%rcx
xorpd  %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdi,8),%xmm1
subsd  (%r14,%rdi,8),%xmm1
subsd  -0x8(%rbp,%rdi,8),%xmm1
subsd  -0x8(%r14,%rdi,8),%xmm1
maxsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rdi,8)
lea    0x1(%rdi),%rax
mov    %rax,%rdi
cmp    %rax,%r12
jne    1a40 <odrrb_+0x920>
xor    %eax,%eax
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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