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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ printf(char *, ...);
void diptst(const double x[], const int *n_, double *dip, int *lo_hi,
            int *ifault, int *gcm, int *lcm, int *mn, int *mj,
            const int *min_is_0, const int *debug) {
  const int n = *n_;
  int mnj, mnmnj, mjk, mjmjk, ig, ih, iv, ix, i, j, k;
  double dip_l, dip_u, dipnew;
  *ifault = 1;
  if (n < 1)
    return;
  *ifault = 2;
  for (k = 1; k <= (n - 1); ++k)
    if (x[k] < x[k - 1])
      return;
  *ifault = 0;
  lo_hi[0] = 0;
  lo_hi[1] = n - 1;
  *dip = (*min_is_0) ? 0. : 1.;
  if (n < 2 || x[n - 1] == x[0])
    goto L_END;
  mn[0] = 0;
  for (j = 1; j <= (n - 1); ++j) {
    mn[j] = j - 1;
    while (1) {
      mnj = mn[j];
      mnmnj = mn[mnj];
      if (mnj == 0 ||
          (x[j] - x[mnj]) * (mnj - mnmnj) < (x[mnj] - x[mnmnj]) * (j - mnj))
        break;
      mn[j] = mnmnj;
    }
  }
  mj[n - 1] = n - 1;
  for (k = n - 2; k >= 0; k--) {
    mj[k] = k + 1;
    while (1) {
      mjk = mj[k];
      mjmjk = mj[mjk];
      if (mjk == (n - 1) ||
          (x[k] - x[mjk]) * (mjk - mjmjk) < (x[mjk] - x[mjmjk]) * (k - mjk))
        break;
      mj[k] = mjmjk;
    }
  }
LOOP_Start:
  gcm[0] = lo_hi[1];
  for (i = 0; gcm[i] > lo_hi[0]; i++)
    gcm[i + 1] = mn[gcm[i]];
  ig = lo_hi[2] = i;
  ix = ig - 1;
  lcm[0] = lo_hi[0];
  for (i = 0; lcm[i] < lo_hi[1]; i++)
    lcm[i + 1] = mj[lcm[i]];
  ih = lo_hi[3] = i;
  iv = 1;
  if (*debug) {
    printf("'dip': LOOP-BEGIN: 2n*D= %-8.5g  [low,high] = [%3d,%3d]", *dip,
           lo_hi[0], lo_hi[1]);
    if (*debug >= 3) {
      printf(" :\n gcm[0:%d] = ", lo_hi[2]);
      for (i = 0; i <= lo_hi[2]; i++)
        printf("%d%s", gcm[i], (i < lo_hi[2]) ? ", " : "\n");
      printf(" lcm[0:%d] = ", lo_hi[3]);
      for (i = 0; i <= lo_hi[3]; i++)
        printf("%d%s", lcm[i], (i < lo_hi[3]) ? ", " : "\n");
    } else {
      printf("; l_lcm/gcm = (%2d,%2d)\n", lo_hi[3], lo_hi[2]);
    }
  }
  long double d = 0.;
  if (lo_hi[2] != 2 || lo_hi[3] != 2) {
    if (*debug)
      printf("  while(gcm[ix] != lcm[iv]) :%s", (*debug >= 2) ? "\n" : " ");
    do {
      long double dx;
      int gcmix = gcm[ix], lcmiv = lcm[iv];
      if (gcmix > lcmiv) {
        int gcmi1 = gcm[ix + 1];
        dx = (lcmiv - gcmi1 + 1) - ((long double)x[lcmiv] - x[gcmi1]) *
                                       (gcmix - gcmi1) / (x[gcmix] - x[gcmi1]);
        ++iv;
        if (dx >= d) {
          d = dx;
          ig = ix + 1;
          ih = iv - 1;
          if (*debug >= 2)
            printf(" L(%d,%d)", ig, ih);
        }
      } else {
        int lcmiv1 = lcm[iv - 1];
        dx = ((long double)x[gcmix] - x[lcmiv1]) * (lcmiv - lcmiv1) /
                 (x[lcmiv] - x[lcmiv1]) -
             (gcmix - lcmiv1 - 1);
        --ix;
        if (dx >= d) {
          d = dx;
          ig = ix + 1;
          ih = iv;
          if (*debug >= 2)
            printf(" G(%d,%d)", ig, ih);
        }
      }
      if (ix < 0)
        ix = 0;
      if (iv > lo_hi[3])
        iv = lo_hi[3];
      if (*debug) {
        if (*debug >= 2)
          printf(" --> ix = %d, iv = %d\n", ix, iv);
        else
          printf(".");
      }
    } while (gcm[ix] != lcm[iv]);
    if (*debug && *debug < 2)
      printf("\n");
  } else {
    d = (*min_is_0) ? 0. : 1.;
    if (*debug)
      printf("  ** (l_lcm,l_gcm) = (%d,%d) ==> d := %g\n", lo_hi[3], lo_hi[2],
             (double)d);
  }
  if (d < *dip)
    goto L_END;
  if (*debug)
    printf("  calculating dip ..");
  int j_best, j_l = -1, j_u = -1;
  dip_l = 0.;
  for (j = ig; j < lo_hi[2]; ++j) {
    double max_t = 1.;
    int j_ = -1, jb = gcm[j + 1], je = gcm[j];
    if (je - jb > 1 && x[je] != x[jb]) {
      double C = (je - jb) / (x[je] - x[jb]);
      for (int jj = jb; jj <= je; ++jj) {
        double t = (jj - jb + 1) - (x[jj] - x[jb]) * C;
        if (max_t < t) {
          max_t = t;
          j_ = jj;
        }
      }
    }
    if (dip_l < max_t) {
      dip_l = max_t;
      j_l = j_;
    }
  }
  dip_u = 0.;
  for (j = ih; j < lo_hi[3]; ++j) {
    double max_t = 1.;
    int j_ = -1, jb = lcm[j], je = lcm[j + 1];
    if (je - jb > 1 && x[je] != x[jb]) {
      double C = (je - jb) / (x[je] - x[jb]);
      for (int jj = jb; jj <= je; ++jj) {
        double t = (x[jj] - x[jb]) * C - (jj - jb - 1);
        if (max_t < t) {
          max_t = t;
          j_ = jj;
        }
      }
    }
    if (dip_u < max_t) {
      dip_u = max_t;
      j_u = j_;
    }
  }
  if (*debug)
    printf(" (dip_l, dip_u) = (%g, %g)", dip_l, dip_u);
  if (dip_u > dip_l) {
    dipnew = dip_u;
    j_best = j_u;
  } else {
    dipnew = dip_l;
    j_best = j_l;
  }
  if (*dip < dipnew) {
    *dip = dipnew;
    if (*debug)
      printf(" -> new larger dip %g (j_best = %d)\n", dipnew, j_best);
  } else if (*debug)
    printf("\n");
  if (lo_hi[0] == gcm[ig] && lo_hi[1] == lcm[ih]) {
    if (*debug)
      printf("No improvement in  low = %d  nor  high = %d --> END\n", lo_hi[0],
             lo_hi[1]);
  } else {
    lo_hi[0] = gcm[ig];
    lo_hi[1] = lcm[ih];
    goto LOOP_Start;
  }
L_END:
  *dip /= (2 * n);
  return;
}


x86 assembly (clang, -O0):
<diptst>:
push   %rbp
mov    %rsp,%rbp
sub    $0x180,%rsp
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    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rax
movl   $0x1,(%rax)
cmpl   $0x1,-0x34(%rbp)
jge    1169 <diptst+0x59>
jmp    1ff2 <diptst+0xee2>
mov    -0x28(%rbp),%rax
movl   $0x2,(%rax)
movl   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     11cc <diptst+0xbc>
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    11b9 <diptst+0xa9>
jmp    1ff2 <diptst+0xee2>
jmp    11be <diptst+0xae>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    117a <diptst+0x6a>
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x20(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    0x28(%rbp),%rax
mov    (%rax),%eax
xorps  %xmm0,%xmm0
movsd  0x1e02(%rip),%xmm1
movsd  %xmm1,-0x170(%rbp)
ff
cmp    $0x0,%eax
movsd  %xmm0,-0x168(%rbp)
ff
jne    1227 <diptst+0x117>
movsd  -0x170(%rbp),%xmm0
ff
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x168(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
cmpl   $0x2,-0x34(%rbp)
jl     1267 <diptst+0x157>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
ucomisd (%rax),%xmm0
jne    126c <diptst+0x15c>
jp     126c <diptst+0x15c>
jmp    1fd8 <diptst+0xec8>
mov    0x18(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     134a <diptst+0x23a>
mov    -0x5c(%rbp),%edx
sub    $0x1,%edx
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x38(%rbp)
je     131f <diptst+0x20f>
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%eax
sub    -0x3c(%rbp),%eax
cvtsi2sd %eax,%xmm0
mulsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x5c(%rbp),%eax
sub    -0x38(%rbp),%eax
cvtsi2sd %eax,%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1324 <diptst+0x214>
jmp    1337 <diptst+0x227>
mov    -0x3c(%rbp),%edx
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    129f <diptst+0x18f>
jmp    133c <diptst+0x22c>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    127d <diptst+0x16d>
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
mov    0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x60(%rbp)
cmpl   $0x0,-0x60(%rbp)
jl     1436 <diptst+0x326>
mov    -0x60(%rbp),%edx
add    $0x1,%edx
mov    0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
mov    0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     140b <diptst+0x2fb>
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x40(%rbp),%eax
sub    -0x44(%rbp),%eax
cvtsi2sd %eax,%xmm0
mulsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%eax
sub    -0x40(%rbp),%eax
cvtsi2sd %eax,%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1410 <diptst+0x300>
jmp    1423 <diptst+0x313>
mov    -0x44(%rbp),%edx
mov    0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1384 <diptst+0x274>
jmp    1428 <diptst+0x318>
mov    -0x60(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x60(%rbp)
jmp    1369 <diptst+0x259>
jmp    143b <diptst+0x32b>
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x0,-0x58(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jle    1497 <diptst+0x387>
mov    0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq -0x58(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    144f <diptst+0x33f>
mov    -0x58(%rbp),%eax
mov    -0x20(%rbp),%rcx
mov    %eax,0x8(%rcx)
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x0,-0x58(%rbp)
mov    0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
cmp    0x4(%rcx),%eax
jge    1509 <diptst+0x3f9>
mov    0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
movslq -0x58(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    14c0 <diptst+0x3b0>
mov    -0x58(%rbp),%eax
mov    -0x20(%rbp),%rcx
mov    %eax,0xc(%rcx)
mov    %eax,-0x4c(%rbp)
movl   $0x1,-0x50(%rbp)
mov    0x30(%rbp),%rax
cmpl   $0x0,(%rax)
je     1662 <diptst+0x552>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    (%rax),%esi
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edx
lea    0x1ac2(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    0x30(%rbp),%rax
cmpl   $0x3,(%rax)
jl     1641 <diptst+0x531>
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%esi
lea    0x1ad8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    0x8(%rcx),%eax
jg     15cb <diptst+0x4bb>
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x58(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
lea    0x1ba6(%rip),%rdx
lea    0x1aad(%rip),%rax
cmp    %edi,%ecx
cmovl  %rax,%rdx
lea    0x1a9b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1576 <diptst+0x466>
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%esi
lea    0x1a80(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    0xc(%rcx),%eax
jg     163c <diptst+0x52c>
mov    0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x58(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
lea    0x1b35(%rip),%rdx
lea    0x1a3c(%rip),%rax
cmp    %edi,%ecx
cmovl  %rax,%rdx
lea    0x1a2a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    15e7 <diptst+0x4d7>
jmp    165d <diptst+0x54d>
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%esi
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edx
lea    0x1a11(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1662 <diptst+0x552>
fldz
fstpt  -0x90(%rbp)
mov    -0x20(%rbp),%rax
cmpl   $0x2,0x8(%rax)
jne    1686 <diptst+0x576>
mov    -0x20(%rbp),%rax
cmpl   $0x2,0xc(%rax)
je     19a8 <diptst+0x898>
mov    0x30(%rbp),%rax
cmpl   $0x0,(%rax)
je     16bc <diptst+0x5ac>
mov    0x30(%rbp),%rax
mov    (%rax),%ecx
lea    0x19b7(%rip),%rsi
lea    0x1aa1(%rip),%rax
cmp    $0x2,%ecx
cmovge %rax,%rsi
lea    0x19cb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    16c1 <diptst+0x5b1>
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xa4(%rbp)
mov    0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0xa8(%rbp),%eax
jle    17ef <diptst+0x6df>
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    0x4(%rax,%rcx,4),%eax
mov    %eax,-0xac(%rbp)
movslq -0xa8(%rbp),%rdx
mov    %edx,%eax
movslq -0xac(%rbp),%rcx
mov    %ecx,%esi
sub    %esi,%eax
add    $0x1,%eax
mov    %eax,-0x14c(%rbp)
fildl  -0x14c(%rbp)
mov    -0x8(%rbp),%rax
fldl   (%rax,%rdx,8)
movsd  (%rax,%rcx,8),%xmm1
movsd  %xmm1,-0x158(%rbp)
ff
fldl   -0x158(%rbp)
fsubrp %st,%st(1)
movslq -0xa4(%rbp),%rcx
mov    %ecx,%edx
sub    %esi,%edx
mov    %edx,-0x150(%rbp)
fildl  -0x150(%rbp)
fmulp  %st,%st(1)
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
fldl   -0x160(%rbp)
fdivrp %st,%st(1)
fsubrp %st,%st(1)
fstpt  -0xa0(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
fldt   -0xa0(%rbp)
fldt   -0x90(%rbp)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jb     17ea <diptst+0x6da>
jmp    17a6 <diptst+0x696>
fldt   -0xa0(%rbp)
fstpt  -0x90(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x50(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    0x30(%rbp),%rax
cmpl   $0x2,(%rax)
jl     17e5 <diptst+0x6d5>
mov    -0x48(%rbp),%esi
mov    -0x4c(%rbp),%edx
lea    0x18c2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    17ea <diptst+0x6da>
jmp    18e9 <diptst+0x7d9>
mov    0x10(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0xffffffff,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xb0(%rbp)
mov    -0x8(%rbp),%rdx
movslq -0xa4(%rbp),%rax
mov    %eax,%ecx
fldl   (%rdx,%rax,8)
movslq -0xb0(%rbp),%rsi
mov    %esi,%eax
movsd  (%rdx,%rsi,8),%xmm1
movsd  %xmm1,-0x140(%rbp)
ff
fldl   -0x140(%rbp)
fsubrp %st,%st(1)
movslq -0xa8(%rbp),%rsi
mov    %esi,%edi
sub    %eax,%edi
mov    %edi,-0x138(%rbp)
fildl  -0x138(%rbp)
fmulp  %st,%st(1)
movsd  (%rdx,%rsi,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
fldl   -0x148(%rbp)
fdivrp %st,%st(1)
not    %eax
add    %ecx,%eax
mov    %eax,-0x134(%rbp)
fildl  -0x134(%rbp)
fsubrp %st,%st(1)
fstpt  -0xa0(%rbp)
mov    -0x54(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x54(%rbp)
fldt   -0xa0(%rbp)
fldt   -0x90(%rbp)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jb     18e4 <diptst+0x7d4>
jmp    18a3 <diptst+0x793>
fldt   -0xa0(%rbp)
fstpt  -0x90(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    0x30(%rbp),%rax
cmpl   $0x2,(%rax)
jl     18df <diptst+0x7cf>
mov    -0x48(%rbp),%esi
mov    -0x4c(%rbp),%edx
lea    0x17d2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    18e4 <diptst+0x7d4>
jmp    18e9 <diptst+0x7d9>
cmpl   $0x0,-0x54(%rbp)
jge    18fa <diptst+0x7ea>
movl   $0x0,-0x54(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    0xc(%rcx),%eax
jle    1914 <diptst+0x804>
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%eax
mov    %eax,-0x50(%rbp)
mov    0x30(%rbp),%rax
cmpl   $0x0,(%rax)
je     195a <diptst+0x84a>
mov    0x30(%rbp),%rax
cmpl   $0x2,(%rax)
jl     1947 <diptst+0x837>
mov    -0x54(%rbp),%esi
mov    -0x50(%rbp),%edx
lea    0x1779(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1955 <diptst+0x845>
lea    0x17ba(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    195a <diptst+0x84a>
jmp    195f <diptst+0x84f>
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x10(%rbp),%rcx
movslq -0x50(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    16c1 <diptst+0x5b1>
mov    0x30(%rbp),%rax
cmpl   $0x0,(%rax)
je     19a3 <diptst+0x893>
mov    0x30(%rbp),%rax
cmpl   $0x2,(%rax)
jge    19a3 <diptst+0x893>
lea    0x17ac(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1a3b <diptst+0x92b>
mov    0x28(%rbp),%rax
mov    (%rax),%eax
test   %eax,%eax
xorps  %xmm0,%xmm0
movsd  0x1645(%rip),%xmm1
movsd  %xmm1,-0x180(%rbp)
ff
movsd  %xmm0,-0x178(%rbp)
ff
jne    19e1 <diptst+0x8d1>
movsd  -0x180(%rbp),%xmm0
ff
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x178(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
fldl   -0x128(%rbp)
fstpt  -0x90(%rbp)
mov    0x30(%rbp),%rax
cmpl   $0x0,(%rax)
je     1a36 <diptst+0x926>
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edx
mov    0xc(%rax),%esi
fldt   -0x90(%rbp)
fstpl  -0x130(%rbp)
movsd  -0x130(%rbp),%xmm0
ff
lea    0x169c(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
jmp    1a3b <diptst+0x92b>
fldt   -0x90(%rbp)
mov    -0x18(%rbp),%rax
fldl   (%rax)
fucomip %st(1),%st
fstp   %st(0)
jbe    1a5b <diptst+0x94b>
jmp    1a56 <diptst+0x946>
jmp    1fd8 <diptst+0xec8>
mov    0x30(%rbp),%rax
cmpl   $0x0,(%rax)
je     1a76 <diptst+0x966>
lea    0x1686(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0xffffffff,-0xb8(%rbp)
ff ff ff
movl   $0xffffffff,-0xbc(%rbp)
ff ff ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    0x8(%rcx),%eax
jge    1c82 <diptst+0xb72>
movsd  0x1550(%rip),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0xffffffff,-0xcc(%rbp)
ff ff ff
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xd0(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xd4(%rbp)
mov    -0xd4(%rbp),%eax
sub    -0xd0(%rbp),%eax
cmp    $0x1,%eax
jle    1c3f <diptst+0xb2f>
mov    -0x8(%rbp),%rax
movslq -0xd4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xd0(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    1b2f <diptst+0xa1f>
jp     1b2f <diptst+0xa1f>
jmp    1c3f <diptst+0xb2f>
mov    -0xd4(%rbp),%eax
sub    -0xd0(%rbp),%eax
cvtsi2sd %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0xd4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0xd0(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0xd0(%rbp),%eax
mov    %eax,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0xd4(%rbp),%eax
jg     1c3a <diptst+0xb2a>
mov    -0xe4(%rbp),%eax
sub    -0xd0(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
mov    -0x8(%rbp),%rax
movslq -0xe4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xd0(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  -0xe0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm1
ff
movsd  -0xf0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1c21 <diptst+0xb11>
movsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0xe4(%rbp),%eax
mov    %eax,-0xcc(%rbp)
jmp    1c26 <diptst+0xb16>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    1b77 <diptst+0xa67>
jmp    1c3f <diptst+0xb2f>
movsd  -0x68(%rbp),%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1c6f <diptst+0xb5f>
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
mov    -0xcc(%rbp),%eax
mov    %eax,-0xb8(%rbp)
jmp    1c74 <diptst+0xb64>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1a98 <diptst+0x988>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    0xc(%rcx),%eax
jge    1e7a <diptst+0xd6a>
movsd  0x1358(%rip),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movl   $0xffffffff,-0xfc(%rbp)
ff ff ff
mov    0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x100(%rbp)
mov    0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x104(%rbp)
mov    -0x104(%rbp),%eax
sub    -0x100(%rbp),%eax
cmp    $0x1,%eax
jle    1e37 <diptst+0xd27>
mov    -0x8(%rbp),%rax
movslq -0x104(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x100(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    1d27 <diptst+0xc17>
jp     1d27 <diptst+0xc17>
jmp    1e37 <diptst+0xd27>
mov    -0x104(%rbp),%eax
sub    -0x100(%rbp),%eax
cvtsi2sd %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x104(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x100(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0x100(%rbp),%eax
mov    %eax,-0x114(%rbp)
mov    -0x114(%rbp),%eax
cmp    -0x104(%rbp),%eax
jg     1e32 <diptst+0xd22>
mov    -0x8(%rbp),%rax
movslq -0x114(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x100(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  -0x110(%rbp),%xmm2
ff
mov    -0x114(%rbp),%eax
sub    -0x100(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0xf8(%rbp),%xmm1
ff
movsd  -0x120(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1e19 <diptst+0xd09>
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x114(%rbp),%eax
mov    %eax,-0xfc(%rbp)
jmp    1e1e <diptst+0xd0e>
mov    -0x114(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x114(%rbp)
jmp    1d6f <diptst+0xc5f>
jmp    1e37 <diptst+0xd27>
movsd  -0x70(%rbp),%xmm1
movsd  -0xf8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1e67 <diptst+0xd57>
movsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
mov    -0xfc(%rbp),%eax
mov    %eax,-0xbc(%rbp)
jmp    1e6c <diptst+0xd5c>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1c90 <diptst+0xb80>
mov    0x30(%rbp),%rax
cmpl   $0x0,(%rax)
je     1e9f <diptst+0xd8f>
movsd  -0x68(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
lea    0x1272(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movsd  -0x70(%rbp),%xmm0
ucomisd -0x68(%rbp),%xmm0
jbe    1eca <diptst+0xdba>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0xbc(%rbp),%eax
mov    %eax,-0xb4(%rbp)
jmp    1ee0 <diptst+0xdd0>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0xb8(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x78(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1f2f <diptst+0xe1f>
movsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x30(%rbp),%rax
cmpl   $0x0,(%rax)
je     1f2a <diptst+0xe1a>
movsd  -0x78(%rbp),%xmm0
mov    -0xb4(%rbp),%esi
lea    0x1202(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
jmp    1f4f <diptst+0xe3f>
mov    0x30(%rbp),%rax
cmpl   $0x0,(%rax)
je     1f4a <diptst+0xe3a>
lea    0x1205(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1f4f <diptst+0xe3f>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    -0x30(%rbp),%rcx
movslq -0x48(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1fab <diptst+0xe9b>
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%eax
mov    0x10(%rbp),%rcx
movslq -0x4c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1fab <diptst+0xe9b>
mov    0x30(%rbp),%rax
cmpl   $0x0,(%rax)
je     1fa6 <diptst+0xe96>
mov    -0x20(%rbp),%rax
mov    (%rax),%esi
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edx
lea    0x11ab(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1fd3 <diptst+0xec3>
mov    -0x30(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,0x4(%rax)
jmp    143b <diptst+0x32b>
jmp    1fd8 <diptst+0xec8>
mov    -0x34(%rbp),%eax
shl    $0x1,%eax
cvtsi2sd %eax,%xmm1
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
add    $0x180,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<diptst>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %rdx,%r13
mov    (%rsi),%edx
movl   $0x1,(%r8)
test   %edx,%edx
jle    11eb <diptst+0xcb>
mov    %rdi,%r15
movl   $0x2,(%r8)
cmp    $0x1,%edx
je     1179 <diptst+0x59>
movsd  (%r15),%xmm0
mov    $0x1,%eax
xchg   %ax,%ax
movapd %xmm0,%xmm1
movsd  (%r15,%rax,8),%xmm0
ucomisd %xmm0,%xmm1
ja     11eb <diptst+0xcb>
add    $0x1,%rax
cmp    %rax,%rdx
jne    1160 <diptst+0x40>
mov    0xd8(%rsp),%rsi
lea    -0x1(%rdx),%eax
movl   $0x0,(%r8)
movl   $0x0,(%rcx)
mov    %eax,0x4(%rcx)
cmpl   $0x0,(%rsi)
mov    %r9,(%rsp)
je     11a3 <diptst+0x83>
xorpd  %xmm0,%xmm0
jmp    11ab <diptst+0x8b>
movsd  0xe55(%rip),%xmm0
movsd  %xmm0,0x0(%r13)
mov    %rdx,0x40(%rsp)
cmp    $0x2,%edx
jl     11cd <diptst+0xad>
mov    %eax,%r8d
movsd  (%r15,%r8,8),%xmm0
ucomisd (%r15),%xmm0
jne    11fd <diptst+0xdd>
jp     11fd <diptst+0xdd>
mov    0x40(%rsp),%rax
add    %eax,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x0(%r13),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13)
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rcx,0x20(%rsp)
mov    0xd0(%rsp),%r9
mov    0xc8(%rsp),%rcx
movl   $0x0,(%rcx)
mov    $0x1,%edx
mov    0x40(%rsp),%r10
mov    (%rsp),%r11
jmp    1239 <diptst+0x119>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    %r10,%rdx
je     128c <diptst+0x16c>
lea    -0x1(%rdx),%esi
nopl   0x0(%rax)
mov    %esi,(%rcx,%rdx,4)
test   %esi,%esi
je     1230 <diptst+0x110>
movslq %esi,%rdi
mov    (%rcx,%rdi,4),%ebp
movslq %ebp,%rbx
movsd  (%r15,%rdx,8),%xmm0
movsd  (%r15,%rdi,8),%xmm1
subsd  %xmm1,%xmm0
mov    %edx,%edi
sub    %esi,%edi
sub    %ebx,%esi
xorps  %xmm2,%xmm2
cvtsi2sd %esi,%xmm2
subsd  (%r15,%rbx,8),%xmm1
xorps  %xmm3,%xmm3
cvtsi2sd %edi,%xmm3
mulsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm3
ucomisd %xmm2,%xmm3
mov    %ebp,%esi
jbe    1240 <diptst+0x120>
jmp    1230 <diptst+0x110>
mov    %eax,(%r9,%r8,4)
lea    -0x2(%r10),%ecx
mov    0xc0(%rsp),%r10
jmp    12ac <diptst+0x18c>
xchg   %ax,%ax
lea    -0x1(%rcx),%rdx
test   %rcx,%rcx
mov    %rdx,%rcx
jle    12fe <diptst+0x1de>
lea    0x1(%rcx),%edx
nop
mov    %edx,(%r9,%rcx,4)
cmp    %eax,%edx
je     12a0 <diptst+0x180>
movslq %edx,%rsi
mov    (%r9,%rsi,4),%edi
movslq %edi,%rbp
movsd  (%r15,%rcx,8),%xmm0
movsd  (%r15,%rsi,8),%xmm1
subsd  %xmm1,%xmm0
mov    %ecx,%esi
sub    %edx,%esi
sub    %ebp,%edx
xorps  %xmm2,%xmm2
cvtsi2sd %edx,%xmm2
subsd  (%r15,%rbp,8),%xmm1
xorps  %xmm3,%xmm3
cvtsi2sd %esi,%xmm3
mulsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm3
ucomisd %xmm2,%xmm3
mov    %edi,%edx
jbe    12b0 <diptst+0x190>
jmp    12a0 <diptst+0x180>
mov    0x20(%rsp),%rbp
mov    0x4(%rbp),%eax
fldz
fstpt  0x7c(%rsp)
mov    %r13,0x28(%rsp)
jmp    133d <diptst+0x21d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %ebx,%rcx
mov    0xc0(%rsp),%r10
mov    %eax,0x0(%rbp)
mov    (%r10,%rcx,4),%eax
mov    %eax,0x4(%rbp)
mov    0xd0(%rsp),%r9
mov    %eax,(%r11)
mov    0x0(%rbp),%ecx
mov    $0x0,%r14d
cmp    %ecx,%eax
jle    1375 <diptst+0x255>
xor    %r14d,%r14d
mov    0xc8(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
cltq
mov    (%rdx,%rax,4),%eax
mov    %eax,0x4(%r11,%r14,4)
add    $0x1,%r14
mov    0x0(%rbp),%ecx
cmp    %ecx,%eax
jg     1360 <diptst+0x240>
mov    %r14d,0x8(%rbp)
mov    %ecx,(%r10)
mov    0x4(%rbp),%edx
xor    %esi,%esi
cmp    %edx,%ecx
jge    13a7 <diptst+0x287>
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movslq %ecx,%rax
mov    (%r9,%rax,4),%ecx
mov    %ecx,0x4(%r10,%rsi,4)
add    $0x1,%rsi
mov    0x4(%rbp),%edx
cmp    %edx,%ecx
jl     1390 <diptst+0x270>
mov    %rsi,0x18(%rsp)
mov    %esi,0xc(%rbp)
mov    0xe0(%rsp),%rax
cmpl   $0x0,(%rax)
je     14d0 <diptst+0x3b0>
mov    0x28(%rsp),%rax
movsd  (%rax),%xmm0
mov    0x0(%rbp),%esi
lea    0xc35(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    0xe0(%rsp),%rax
cmpl   $0x3,(%rax)
jl     14e0 <diptst+0x3c0>
mov    0x8(%rbp),%esi
lea    0xc4b(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x8(%rbp),%eax
test   %eax,%eax
mov    %rbp,%r12
mov    (%rsp),%rbp
lea    0xc42(%rip),%r13
js     1456 <diptst+0x336>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x0(%rbp,%rbx,4),%esi
cltq
cmp    %rax,%rbx
lea    0xd18(%rip),%rdx
lea    0xc1f(%rip),%rax
cmovl  %rax,%rdx
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x1(%rbx),%rcx
movslq 0x8(%r12),%rax
cmp    %rax,%rbx
mov    %rcx,%rbx
jl     1420 <diptst+0x300>
mov    0xc(%r12),%esi
lea    0xbf7(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc(%r12),%eax
test   %eax,%eax
mov    %r12,%rbp
mov    0xc0(%rsp),%r10
lea    0xcc6(%rip),%r12
js     14d0 <diptst+0x3b0>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
mov    (%r10,%rbx,4),%esi
cltq
cmp    %rax,%rbx
mov    %r12,%rdx
lea    0xbb3(%rip),%rax
cmovl  %rax,%rdx
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc0(%rsp),%r10
lea    0x1(%rbx),%rcx
movslq 0xc(%rbp),%rax
cmp    %rax,%rbx
mov    %rcx,%rbx
jl     1490 <diptst+0x370>
nopl   0x0(%rax)
cmpl   $0x2,0x8(%rbp)
je     1502 <diptst+0x3e2>
jmp    1570 <diptst+0x450>
nopl   0x0(%rax,%rax,1)
mov    0x8(%rbp),%edx
mov    0xc(%rbp),%esi
lea    0xb7a(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc0(%rsp),%r10
cmpl   $0x2,0x8(%rbp)
jne    1570 <diptst+0x450>
cmpl   $0x2,0xc(%rbp)
jne    1570 <diptst+0x450>
mov    0xd8(%rsp),%rax
cmpl   $0x0,(%rax)
movsd  0xae5(%rip),%xmm0
je     1521 <diptst+0x401>
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x50(%rsp)
fldl   0x50(%rsp)
mov    0xe0(%rsp),%rax
cmpl   $0x0,(%rax)
mov    0x28(%rsp),%r13
je     17f7 <diptst+0x6d7>
lea    0xb83(%rip),%rdi
mov    $0x2,%esi
mov    $0x2,%edx
mov    $0x1,%al
fstpt  0x8(%rsp)
call   1040 <printf@plt>
fldt   0x8(%rsp)
mov    0xc0(%rsp),%r10
jmp    17f7 <diptst+0x6d7>
xchg   %ax,%ax
mov    0xe0(%rsp),%rax
mov    (%rax),%eax
test   %eax,%eax
je     15a9 <diptst+0x489>
cmp    $0x2,%eax
lea    0xacf(%rip),%rsi
lea    0xbb9(%rip),%rax
cmovge %rax,%rsi
lea    0xae6(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc0(%rsp),%r10
lea    -0x1(%r14),%ebp
mov    0x4(%r10),%eax
mov    $0x1,%r13d
fldt   0x7c(%rsp)
mov    (%rsp),%rdi
jmp    15fc <diptst+0x4dc>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0x2e,%edi
call   1030 <putchar@plt>
mov    (%rsp),%rdi
mov    0xc0(%rsp),%r10
fldt   0x8(%rsp)
mov    %ebp,%ecx
movslq %r13d,%rax
mov    (%r10,%rax,4),%eax
cmp    %eax,(%rdi,%rcx,4)
je     17c0 <diptst+0x6a0>
movslq %ebp,%rdx
movslq (%rdi,%rdx,4),%rcx
cmp    %eax,%ecx
jle    1670 <diptst+0x550>
movslq 0x4(%rdi,%rdx,4),%rdx
movslq %eax,%rsi
sub    %edx,%eax
add    $0x1,%eax
mov    %eax,0x34(%rsp)
fldl   (%r15,%rsi,8)
movsd  (%r15,%rdx,8),%xmm0
movsd  %xmm0,0x60(%rsp)
fsubl  0x60(%rsp)
mov    %ecx,%eax
sub    %edx,%eax
mov    %eax,0x30(%rsp)
fimull 0x30(%rsp)
movsd  (%r15,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x58(%rsp)
fdivl  0x58(%rsp)
fisubrl 0x34(%rsp)
lea    0x1(%r13),%r12d
fucomi %st(1),%st
jae    16d0 <diptst+0x5b0>
fstp   %st(0)
mov    %ebp,%ebx
jmp    175c <diptst+0x63c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %r13d,%rdx
movslq -0x4(%r10,%rdx,4),%rdx
fldl   (%r15,%rcx,8)
movsd  (%r15,%rdx,8),%xmm0
movsd  %xmm0,0x70(%rsp)
fsubl  0x70(%rsp)
movslq %eax,%rsi
sub    %edx,%eax
mov    %eax,0x38(%rsp)
fimull 0x38(%rsp)
movsd  (%r15,%rsi,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x68(%rsp)
fdivl  0x68(%rsp)
not    %edx
add    %ecx,%edx
mov    %edx,0x3c(%rsp)
fisubl 0x3c(%rsp)
lea    -0x1(%rbp),%ebx
fucomi %st(1),%st
jae    1710 <diptst+0x5f0>
fstp   %st(0)
mov    %r13d,%r12d
jmp    175c <diptst+0x63c>
nopw   0x0(%rax,%rax,1)
fstp   %st(1)
lea    0x1(%rbp),%r14d
mov    0xe0(%rsp),%rax
cmpl   $0x2,(%rax)
jl     1748 <diptst+0x628>
lea    0x9b6(%rip),%rdi
mov    %r14d,%esi
mov    %r13d,%edx
xor    %eax,%eax
fstpt  0x8(%rsp)
call   1040 <printf@plt>
mov    0xc0(%rsp),%r10
mov    (%rsp),%rdi
fldt   0x8(%rsp)
jmp    1748 <diptst+0x628>
nopl   (%rax)
fstp   %st(1)
mov    0xe0(%rsp),%rax
cmpl   $0x2,(%rax)
jl     1751 <diptst+0x631>
lea    0x984(%rip),%rdi
mov    %ebp,%esi
mov    %r13d,%edx
xor    %eax,%eax
fstpt  0x8(%rsp)
call   1040 <printf@plt>
mov    0xc0(%rsp),%r10
mov    (%rsp),%rdi
fldt   0x8(%rsp)
jmp    1751 <diptst+0x631>
mov    %ebp,%ebx
mov    %r13,0x18(%rsp)
jmp    175c <diptst+0x63c>
mov    %r13d,%r12d
mov    %r13,0x18(%rsp)
mov    %ebp,%r14d
test   %ebx,%ebx
mov    %ebx,%ebp
mov    $0x0,%eax
cmovs  %eax,%ebp
mov    0x20(%rsp),%rax
mov    0xc(%rax),%eax
cmp    %eax,%r12d
mov    %r12d,%r13d
cmovg  %eax,%r13d
mov    0xe0(%rsp),%rax
mov    (%rax),%eax
test   %eax,%eax
je     15ea <diptst+0x4ca>
fstpt  0x8(%rsp)
cmp    $0x2,%eax
jl     15d0 <diptst+0x4b0>
lea    0x914(%rip),%rdi
mov    %ebp,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1040 <printf@plt>
jmp    15da <diptst+0x4ba>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0xe0(%rsp),%rax
mov    (%rax),%eax
test   %eax,%eax
je     17ed <diptst+0x6cd>
cmp    $0x1,%eax
jg     17ed <diptst+0x6cd>
mov    $0xa,%edi
fstpt  0x8(%rsp)
call   1030 <putchar@plt>
fldt   0x8(%rsp)
mov    0xc0(%rsp),%r10
mov    0x28(%rsp),%r13
mov    0x20(%rsp),%rbp
fldl   0x0(%r13)
fucomip %st(1),%st
fstp   %st(0)
ja     11cd <diptst+0xad>
mov    0xe0(%rsp),%rax
cmpl   $0x0,(%rax)
je     1828 <diptst+0x708>
lea    0x8dc(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc0(%rsp),%r10
movslq 0x8(%rbp),%r8
xorpd  %xmm1,%xmm1
mov    $0xffffffff,%r13d
movslq %r14d,%rax
mov    $0xffffffff,%r12d
xorpd  %xmm0,%xmm0
cmp    %r8d,%r14d
mov    %rax,%r14
mov    (%rsp),%r11
movsd  0x7aa(%rip),%xmm8
jge    19f0 <diptst+0x8d0>
mov    (%r11,%r14,4),%edi
mov    $0xffffffff,%r12d
xorpd  %xmm7,%xmm7
mov    %r14,%rdx
jmp    1899 <diptst+0x779>
movapd %xmm3,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
ucomisd %xmm7,%xmm0
cmova  %esi,%r12d
maxsd  %xmm7,%xmm0
movapd %xmm0,%xmm7
cmp    %r8,%rdx
je     19f0 <diptst+0x8d0>
mov    %edi,%ecx
mov    0x4(%r11,%rdx,4),%edi
add    $0x1,%rdx
mov    %ecx,%ebx
sub    %edi,%ebx
movapd %xmm8,%xmm0
mov    $0xffffffff,%esi
cmp    $0x2,%ebx
jl     1880 <diptst+0x760>
movslq %edi,%rbp
movslq %ecx,%rax
movsd  (%r15,%rax,8),%xmm3
movsd  (%r15,%rbp,8),%xmm5
ucomisd %xmm5,%xmm3
movapd %xmm8,%xmm0
mov    $0xffffffff,%esi
jne    18db <diptst+0x7bb>
jnp    1880 <diptst+0x760>
movapd %xmm8,%xmm0
mov    $0xffffffff,%esi
cmp    %edi,%ecx
jl     1880 <diptst+0x760>
xorps  %xmm2,%xmm2
cvtsi2sd %ebx,%xmm2
subsd  %xmm5,%xmm3
divsd  %xmm3,%xmm2
movapd %xmm5,%xmm4
subsd  %xmm5,%xmm4
mulsd  %xmm2,%xmm4
movapd %xmm8,%xmm3
subsd  %xmm4,%xmm3
ucomisd %xmm8,%xmm3
mov    $0xffffffff,%esi
cmova  %edi,%esi
lea    0x1(%rcx),%r9d
maxsd  %xmm8,%xmm3
lea    0x1(%rbp),%rax
cmp    %eax,%r9d
je     186f <diptst+0x74f>
lea    0x1(%rdi),%r10d
test   $0x1,%bl
jne    193b <diptst+0x81b>
jmp    1974 <diptst+0x854>
mov    $0x1,%ebx
sub    %edi,%ebx
movsd  0x8(%r15,%rbp,8),%xmm4
add    %eax,%ebx
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
subsd  %xmm5,%xmm4
mulsd  %xmm2,%xmm4
subsd  %xmm4,%xmm0
ucomisd %xmm3,%xmm0
maxsd  %xmm3,%xmm0
cmova  %eax,%esi
add    $0x2,%rbp
mov    %rbp,%rax
movapd %xmm0,%xmm3
cmp    %r10d,%ecx
mov    0xc0(%rsp),%r10
je     1880 <diptst+0x760>
mov    %eax,%ecx
sub    %edi,%ecx
add    $0x2,%ecx
movapd %xmm3,%xmm0
lea    -0x1(%rcx),%ebp
xorps  %xmm3,%xmm3
cvtsi2sd %ebp,%xmm3
movsd  (%r15,%rax,8),%xmm4
subsd  %xmm5,%xmm4
mulsd  %xmm2,%xmm4
subsd  %xmm4,%xmm3
ucomisd %xmm0,%xmm3
movsd  0x8(%r15,%rax,8),%xmm4
cmova  %eax,%esi
maxsd  %xmm0,%xmm3
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
subsd  %xmm5,%xmm4
mulsd  %xmm2,%xmm4
subsd  %xmm4,%xmm0
ucomisd %xmm3,%xmm0
lea    0x1(%rax),%ebp
cmova  %ebp,%esi
maxsd  %xmm3,%xmm0
add    $0x2,%ecx
add    $0x2,%rax
cmp    %eax,%r9d
jne    1990 <diptst+0x870>
jmp    1880 <diptst+0x760>
mov    0x20(%rsp),%rax
movslq 0xc(%rax),%r8
cmp    %r8d,0x18(%rsp)
jge    1ba0 <diptst+0xa80>
movslq 0x18(%rsp),%rcx
mov    (%r10,%rcx,4),%edi
xorpd  %xmm6,%xmm6
mov    $0xffffffff,%r13d
jmp    1a39 <diptst+0x919>
movapd %xmm3,%xmm1
nopl   (%rax)
ucomisd %xmm6,%xmm1
maxsd  %xmm6,%xmm1
cmova  %esi,%r13d
movapd %xmm1,%xmm6
cmp    %r8,%rcx
je     1ba0 <diptst+0xa80>
mov    %edi,%edx
mov    0x4(%r10,%rcx,4),%edi
add    $0x1,%rcx
mov    %edi,%ebx
sub    %edx,%ebx
movapd %xmm8,%xmm1
mov    $0xffffffff,%esi
cmp    $0x2,%ebx
jl     1a20 <diptst+0x900>
movslq %edi,%rax
movsd  (%r15,%rax,8),%xmm3
movslq %edx,%rax
movsd  (%r15,%rax,8),%xmm7
ucomisd %xmm7,%xmm3
movapd %xmm8,%xmm1
mov    $0xffffffff,%esi
jne    1a7b <diptst+0x95b>
jnp    1a20 <diptst+0x900>
movapd %xmm8,%xmm1
mov    $0xffffffff,%esi
cmp    %edx,%edi
jl     1a20 <diptst+0x900>
xorps  %xmm2,%xmm2
cvtsi2sd %ebx,%xmm2
subsd  %xmm7,%xmm3
divsd  %xmm3,%xmm2
movapd %xmm7,%xmm3
subsd  %xmm7,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm8,%xmm3
ucomisd %xmm8,%xmm3
mov    $0xffffffff,%esi
cmova  %edx,%esi
lea    0x1(%rdi),%r9d
maxsd  %xmm8,%xmm3
lea    0x1(%rax),%rbp
cmp    %ebp,%r9d
je     1a19 <diptst+0x8f9>
lea    0x1(%rdx),%r10d
test   $0x1,%bl
jne    1ad7 <diptst+0x9b7>
jmp    1b0d <diptst+0x9ed>
mov    %edx,%ebx
not    %ebx
movsd  0x8(%r15,%rax,8),%xmm1
subsd  %xmm7,%xmm1
add    %ebp,%ebx
xorps  %xmm4,%xmm4
cvtsi2sd %ebx,%xmm4
mulsd  %xmm2,%xmm1
subsd  %xmm4,%xmm1
ucomisd %xmm3,%xmm1
maxsd  %xmm3,%xmm1
cmova  %ebp,%esi
add    $0x2,%rax
mov    %rax,%rbp
movapd %xmm1,%xmm3
cmp    %r10d,%edi
mov    0xc0(%rsp),%r10
je     1a20 <diptst+0x900>
mov    %ebp,%eax
sub    %edx,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r15,%rbp,8),%xmm4
subsd  %xmm7,%xmm4
lea    -0x1(%rax),%edx
xorps  %xmm5,%xmm5
cvtsi2sd %edx,%xmm5
mulsd  %xmm2,%xmm4
subsd  %xmm5,%xmm4
ucomisd %xmm3,%xmm4
movsd  0x8(%r15,%rbp,8),%xmm1
cmova  %ebp,%esi
maxsd  %xmm3,%xmm4
subsd  %xmm7,%xmm1
xorps  %xmm3,%xmm3
cvtsi2sd %eax,%xmm3
mulsd  %xmm2,%xmm1
subsd  %xmm3,%xmm1
ucomisd %xmm4,%xmm1
lea    0x1(%rbp),%edx
cmova  %edx,%esi
maxsd  %xmm4,%xmm1
add    $0x2,%eax
add    $0x2,%rbp
movapd %xmm1,%xmm3
cmp    %ebp,%r9d
jne    1b30 <diptst+0xa10>
jmp    1a20 <diptst+0x900>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xe0(%rsp),%rax
cmpl   $0x0,(%rax)
je     1bd7 <diptst+0xab7>
lea    0x556(%rip),%rdi
mov    $0x2,%al
movsd  %xmm1,0x8(%rsp)
movsd  %xmm0,0x48(%rsp)
call   1040 <printf@plt>
movsd  0x48(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
mov    (%rsp),%r11
ucomisd %xmm0,%xmm1
cmova  %r13d,%r12d
maxsd  %xmm0,%xmm1
mov    0x28(%rsp),%r13
ucomisd 0x0(%r13),%xmm1
mov    0x20(%rsp),%rbp
jbe    1c30 <diptst+0xb10>
movsd  %xmm1,0x0(%r13)
mov    0xe0(%rsp),%rax
cmpl   $0x0,(%rax)
mov    0x18(%rsp),%rbx
je     1c50 <diptst+0xb30>
lea    0x511(%rip),%rdi
movapd %xmm1,%xmm0
mov    %r12d,%esi
mov    $0x1,%al
call   1040 <printf@plt>
jmp    1c4c <diptst+0xb2c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xe0(%rsp),%rax
cmpl   $0x0,(%rax)
mov    0x18(%rsp),%rbx
je     1c50 <diptst+0xb30>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    (%rsp),%r11
mov    0x0(%rbp),%esi
mov    (%r11,%r14,4),%eax
cmp    %eax,%esi
jne    1320 <diptst+0x200>
mov    0x4(%rbp),%edx
movslq %ebx,%rcx
mov    0xc0(%rsp),%r10
cmp    (%r10,%rcx,4),%edx
jne    132b <diptst+0x20b>
mov    0xe0(%rsp),%rax
cmpl   $0x0,(%rax)
je     11cd <diptst+0xad>
lea    0x4bb(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    11cd <diptst+0xad>

LLVM IR (-O0):
@.str = [56 x i8] c"'dip': LOOP-BEGIN: 2n*D= %-8.5g [low,high] = [%3d,%3d]\00"
@.str.1 = [17 x i8] c" :\0A gcm[0:%d] = \00"
@.str.2 = [5 x i8] c"%d%s\00"
@.str.3 = [3 x i8] c", \00"
@.str.4 = [2 x i8] c"\0A\00"
@.str.5 = [14 x i8] c" lcm[0:%d] = \00"
@.str.6 = [25 x i8] c"; l_lcm/gcm = (%2d,%2d)\0A\00"
@.str.7 = [32 x i8] c" while(gcm[ix] != lcm[iv]) :%s\00"
@.str.8 = [2 x i8] c" \00"
@.str.9 = [10 x i8] c" L(%d,%d)\00"
@.str.10 = [10 x i8] c" G(%d,%d)\00"
@.str.11 = [23 x i8] c" --> ix = %d, iv = %d\0A\00"
@.str.12 = [2 x i8] c".\00"
@.str.13 = [42 x i8] c" ** (l_lcm,l_gcm) = (%d,%d) ==> d := %g\0A\00"
@.str.14 = [21 x i8] c" calculating dip ..\00"
@.str.15 = [27 x i8] c" (dip_l, dip_u) = (%g, %g)\00"
@.str.16 = [37 x i8] c" -> new larger dip %g (j_best = %d)\0A\00"
@.str.17 = [53 x i8] c"No improvement in low = %d nor high = %d --> END\0A\00"
define void @diptst(double* %0, i32* %1, double* %2, i32* %3, i32* %4, i32* %5, i32* %6, i32* %7, i32* %8, i32* %9, i32* %10) {
%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 i32*
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca double
%36 = alloca double
%37 = alloca double
%38 = alloca x86_fp80
%39 = alloca x86_fp80
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32
%43 = alloca i32
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
%47 = alloca double
%48 = alloca i32
%49 = alloca i32
%50 = alloca i32
%51 = alloca double
%52 = alloca i32
%53 = alloca double
%54 = alloca double
%55 = alloca i32
%56 = alloca i32
%57 = alloca i32
%58 = alloca double
%59 = alloca i32
%60 = alloca double
store double* %0, double** %12
store i32* %1, i32** %13
store double* %2, double** %14
store i32* %3, i32** %15
store i32* %4, i32** %16
store i32* %5, i32** %17
store i32* %6, i32** %18
store i32* %7, i32** %19
store i32* %8, i32** %20
store i32* %9, i32** %21
store i32* %10, i32** %22
%61 = load i32*, i32** %13
%62 = load i32, i32* %61
store i32 %62, i32* %23
%63 = load i32*, i32** %16
store i32 1, i32* %63
%64 = load i32, i32* %23
%65 = icmp slt i32 %64, 1
br i1 %65, label %66, label %67
66: ; preds = %11
br label %980
67: ; preds = %11
%68 = load i32*, i32** %16
store i32 2, i32* %68
store i32 1, i32* %34
br label %69
69: ; preds = %89, %67
%70 = load i32, i32* %34
%71 = load i32, i32* %23
%72 = sub nsw i32 %71, 1
%73 = icmp sle i32 %70, %72
br i1 %73, label %74, label %92
74: ; preds = %69
%75 = load double*, double** %12
%76 = load i32, i32* %34
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds double, double* %75, i64 %77
%79 = load double, double* %78
%80 = load double*, double** %12
%81 = load i32, i32* %34
%82 = sub nsw i32 %81, 1
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds double, double* %80, i64 %83
%85 = load double, double* %84
%86 = fcmp olt double %79, %85
br i1 %86, label %87, label %88
87: ; preds = %74
br label %980
88: ; preds = %74
br label %89
89: ; preds = %88
%90 = load i32, i32* %34
%91 = add nsw i32 %90, 1
store i32 %91, i32* %34
br label %69
92: ; preds = %69
%93 = load i32*, i32** %16
store i32 0, i32* %93
%94 = load i32*, i32** %15
%95 = getelementptr inbounds i32, i32* %94, i64 0
store i32 0, i32* %95
%96 = load i32, i32* %23
%97 = sub nsw i32 %96, 1
%98 = load i32*, i32** %15
%99 = getelementptr inbounds i32, i32* %98, i64 1
store i32 %97, i32* %99
%100 = load i32*, i32** %21
%101 = load i32, i32* %100
%102 = icmp ne i32 %101, 0
%103 = zext i1 %102 to i64
%104 = select i1 %102, double 0.000000e+00, double 1.000000e+00
%105 = load double*, double** %14
store double %104, double* %105
%106 = load i32, i32* %23
%107 = icmp slt i32 %106, 2
br i1 %107, label %119, label %108
108: ; preds = %92
%109 = load double*, double** %12
%110 = load i32, i32* %23
%111 = sub nsw i32 %110, 1
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds double, double* %109, i64 %112
%114 = load double, double* %113
%115 = load double*, double** %12
%116 = getelementptr inbounds double, double* %115, i64 0
%117 = load double, double* %116
%118 = fcmp oeq double %114, %117
br i1 %118, label %119, label %120
119: ; preds = %108, %92
br label %973
120: ; preds = %108
%121 = load i32*, i32** %19
%122 = getelementptr inbounds i32, i32* %121, i64 0
store i32 0, i32* %122
store i32 1, i32* %33
br label %123
123: ; preds = %190, %120
%124 = load i32, i32* %33
%125 = load i32, i32* %23
%126 = sub nsw i32 %125, 1
%127 = icmp sle i32 %124, %126
br i1 %127, label %128, label %193
128: ; preds = %123
%129 = load i32, i32* %33
%130 = sub nsw i32 %129, 1
%131 = load i32*, i32** %19
%132 = load i32, i32* %33
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds i32, i32* %131, i64 %133
store i32 %130, i32* %134
br label %135
135: ; preds = %128, %183
%136 = load i32*, i32** %19
%137 = load i32, i32* %33
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds i32, i32* %136, i64 %138
%140 = load i32, i32* %139
store i32 %140, i32* %24
%141 = load i32*, i32** %19
%142 = load i32, i32* %24
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds i32, i32* %141, i64 %143
%145 = load i32, i32* %144
store i32 %145, i32* %25
%146 = load i32, i32* %24
%147 = icmp eq i32 %146, 0
br i1 %147, label %182, label %148
148: ; preds = %135
%149 = load double*, double** %12
%150 = load i32, i32* %33
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds double, double* %149, i64 %151
%153 = load double, double* %152
%154 = load double*, double** %12
%155 = load i32, i32* %24
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds double, double* %154, i64 %156
%158 = load double, double* %157
%159 = fsub double %153, %158
%160 = load i32, i32* %24
%161 = load i32, i32* %25
%162 = sub nsw i32 %160, %161
%163 = sitofp i32 %162 to double
%164 = fmul double %159, %163
%165 = load double*, double** %12
%166 = load i32, i32* %24
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds double, double* %165, i64 %167
%169 = load double, double* %168
%170 = load double*, double** %12
%171 = load i32, i32* %25
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds double, double* %170, i64 %172
%174 = load double, double* %173
%175 = fsub double %169, %174
%176 = load i32, i32* %33
%177 = load i32, i32* %24
%178 = sub nsw i32 %176, %177
%179 = sitofp i32 %178 to double
%180 = fmul double %175, %179
%181 = fcmp olt double %164, %180
br i1 %181, label %182, label %183
182: ; preds = %148, %135
br label %189
183: ; preds = %148
%184 = load i32, i32* %25
%185 = load i32*, i32** %19
%186 = load i32, i32* %33
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds i32, i32* %185, i64 %187
store i32 %184, i32* %188
br label %135
189: ; preds = %182
br label %190
190: ; preds = %189
%191 = load i32, i32* %33
%192 = add nsw i32 %191, 1
store i32 %192, i32* %33
br label %123
193: ; preds = %123
%194 = load i32, i32* %23
%195 = sub nsw i32 %194, 1
%196 = load i32*, i32** %20
%197 = load i32, i32* %23
%198 = sub nsw i32 %197, 1
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds i32, i32* %196, i64 %199
store i32 %195, i32* %200
%201 = load i32, i32* %23
%202 = sub nsw i32 %201, 2
store i32 %202, i32* %34
br label %203
203: ; preds = %270, %193
%204 = load i32, i32* %34
%205 = icmp sge i32 %204, 0
br i1 %205, label %206, label %273
206: ; preds = %203
%207 = load i32, i32* %34
%208 = add nsw i32 %207, 1
%209 = load i32*, i32** %20
%210 = load i32, i32* %34
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds i32, i32* %209, i64 %211
store i32 %208, i32* %212
br label %213
213: ; preds = %206, %263
%214 = load i32*, i32** %20
%215 = load i32, i32* %34
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds i32, i32* %214, i64 %216
%218 = load i32, i32* %217
store i32 %218, i32* %26
%219 = load i32*, i32** %20
%220 = load i32, i32* %26
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds i32, i32* %219, i64 %221
%223 = load i32, i32* %222
store i32 %223, i32* %27
%224 = load i32, i32* %26
%225 = load i32, i32* %23
%226 = sub nsw i32 %225, 1
%227 = icmp eq i32 %224, %226
br i1 %227, label %262, label %228
228: ; preds = %213
%229 = load double*, double** %12
%230 = load i32, i32* %34
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds double, double* %229, i64 %231
%233 = load double, double* %232
%234 = load double*, double** %12
%235 = load i32, i32* %26
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds double, double* %234, i64 %236
%238 = load double, double* %237
%239 = fsub double %233, %238
%240 = load i32, i32* %26
%241 = load i32, i32* %27
%242 = sub nsw i32 %240, %241
%243 = sitofp i32 %242 to double
%244 = fmul double %239, %243
%245 = load double*, double** %12
%246 = load i32, i32* %26
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds double, double* %245, i64 %247
%249 = load double, double* %248
%250 = load double*, double** %12
%251 = load i32, i32* %27
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds double, double* %250, i64 %252
%254 = load double, double* %253
%255 = fsub double %249, %254
%256 = load i32, i32* %34
%257 = load i32, i32* %26
%258 = sub nsw i32 %256, %257
%259 = sitofp i32 %258 to double
%260 = fmul double %255, %259
%261 = fcmp olt double %244, %260
br i1 %261, label %262, label %263
262: ; preds = %228, %213
br label %269
263: ; preds = %228
%264 = load i32, i32* %27
%265 = load i32*, i32** %20
%266 = load i32, i32* %34
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds i32, i32* %265, i64 %267
store i32 %264, i32* %268
br label %213
269: ; preds = %262
br label %270
270: ; preds = %269
%271 = load i32, i32* %34
%272 = add nsw i32 %271, -1
store i32 %272, i32* %34
br label %203
273: ; preds = %203
br label %274
274: ; preds = %957, %273
%275 = load i32*, i32** %15
%276 = getelementptr inbounds i32, i32* %275, i64 1
%277 = load i32, i32* %276
%278 = load i32*, i32** %17
%279 = getelementptr inbounds i32, i32* %278, i64 0
store i32 %277, i32* %279
store i32 0, i32* %32
br label %280
280: ; preds = %305, %274
%281 = load i32*, i32** %17
%282 = load i32, i32* %32
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds i32, i32* %281, i64 %283
%285 = load i32, i32* %284
%286 = load i32*, i32** %15
%287 = getelementptr inbounds i32, i32* %286, i64 0
%288 = load i32, i32* %287
%289 = icmp sgt i32 %285, %288
br i1 %289, label %290, label %308
290: ; preds = %280
%291 = load i32*, i32** %19
%292 = load i32*, i32** %17
%293 = load i32, i32* %32
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds i32, i32* %292, i64 %294
%296 = load i32, i32* %295
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds i32, i32* %291, i64 %297
%299 = load i32, i32* %298
%300 = load i32*, i32** %17
%301 = load i32, i32* %32
%302 = add nsw i32 %301, 1
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds i32, i32* %300, i64 %303
store i32 %299, i32* %304
br label %305
305: ; preds = %290
%306 = load i32, i32* %32
%307 = add nsw i32 %306, 1
store i32 %307, i32* %32
br label %280
308: ; preds = %280
%309 = load i32, i32* %32
%310 = load i32*, i32** %15
%311 = getelementptr inbounds i32, i32* %310, i64 2
store i32 %309, i32* %311
store i32 %309, i32* %28
%312 = load i32, i32* %28
%313 = sub nsw i32 %312, 1
store i32 %313, i32* %31
%314 = load i32*, i32** %15
%315 = getelementptr inbounds i32, i32* %314, i64 0
%316 = load i32, i32* %315
%317 = load i32*, i32** %18
%318 = getelementptr inbounds i32, i32* %317, i64 0
store i32 %316, i32* %318
store i32 0, i32* %32
br label %319
319: ; preds = %344, %308
%320 = load i32*, i32** %18
%321 = load i32, i32* %32
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds i32, i32* %320, i64 %322
%324 = load i32, i32* %323
%325 = load i32*, i32** %15
%326 = getelementptr inbounds i32, i32* %325, i64 1
%327 = load i32, i32* %326
%328 = icmp slt i32 %324, %327
br i1 %328, label %329, label %347
329: ; preds = %319
%330 = load i32*, i32** %20
%331 = load i32*, i32** %18
%332 = load i32, i32* %32
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds i32, i32* %331, i64 %333
%335 = load i32, i32* %334
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds i32, i32* %330, i64 %336
%338 = load i32, i32* %337
%339 = load i32*, i32** %18
%340 = load i32, i32* %32
%341 = add nsw i32 %340, 1
%342 = sext i32 %341 to i64
%343 = getelementptr inbounds i32, i32* %339, i64 %342
store i32 %338, i32* %343
br label %344
344: ; preds = %329
%345 = load i32, i32* %32
%346 = add nsw i32 %345, 1
store i32 %346, i32* %32
br label %319
347: ; preds = %319
%348 = load i32, i32* %32
%349 = load i32*, i32** %15
%350 = getelementptr inbounds i32, i32* %349, i64 3
store i32 %348, i32* %350
store i32 %348, i32* %29
store i32 1, i32* %30
%351 = load i32*, i32** %22
%352 = load i32, i32* %351
%353 = icmp ne i32 %352, 0
br i1 %353, label %354, label %433
354: ; preds = %347
%355 = load double*, double** %14
%356 = load double, double* %355
%357 = load i32*, i32** %15
%358 = getelementptr inbounds i32, i32* %357, i64 0
%359 = load i32, i32* %358
%360 = load i32*, i32** %15
%361 = getelementptr inbounds i32, i32* %360, i64 1
%362 = load i32, i32* %361
%363 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str, i64 0, i64 0), double %356, i32 %359, i32 %362)
%364 = load i32*, i32** %22
%365 = load i32, i32* %364
%366 = icmp sge i32 %365, 3
br i1 %366, label %367, label %424
367: ; preds = %354
%368 = load i32*, i32** %15
%369 = getelementptr inbounds i32, i32* %368, i64 2
%370 = load i32, i32* %369
%371 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.1, i64 0, i64 0), i32 %370)
store i32 0, i32* %32
br label %372
372: ; preds = %392, %367
%373 = load i32, i32* %32
%374 = load i32*, i32** %15
%375 = getelementptr inbounds i32, i32* %374, i64 2
%376 = load i32, i32* %375
%377 = icmp sle i32 %373, %376
br i1 %377, label %378, label %395
378: ; preds = %372
%379 = load i32*, i32** %17
%380 = load i32, i32* %32
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds i32, i32* %379, i64 %381
%383 = load i32, i32* %382
%384 = load i32, i32* %32
%385 = load i32*, i32** %15
%386 = getelementptr inbounds i32, i32* %385, i64 2
%387 = load i32, i32* %386
%388 = icmp slt i32 %384, %387
%389 = zext i1 %388 to i64
%390 = select i1 %388, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0)
%391 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %383, i8* %390)
br label %392
392: ; preds = %378
%393 = load i32, i32* %32
%394 = add nsw i32 %393, 1
store i32 %394, i32* %32
br label %372
395: ; preds = %372
%396 = load i32*, i32** %15
%397 = getelementptr inbounds i32, i32* %396, i64 3
%398 = load i32, i32* %397
%399 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.5, i64 0, i64 0), i32 %398)
store i32 0, i32* %32
br label %400
400: ; preds = %420, %395
%401 = load i32, i32* %32
%402 = load i32*, i32** %15
%403 = getelementptr inbounds i32, i32* %402, i64 3
%404 = load i32, i32* %403
%405 = icmp sle i32 %401, %404
br i1 %405, label %406, label %423
406: ; preds = %400
%407 = load i32*, i32** %18
%408 = load i32, i32* %32
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds i32, i32* %407, i64 %409
%411 = load i32, i32* %410
%412 = load i32, i32* %32
%413 = load i32*, i32** %15
%414 = getelementptr inbounds i32, i32* %413, i64 3
%415 = load i32, i32* %414
%416 = icmp slt i32 %412, %415
%417 = zext i1 %416 to i64
%418 = select i1 %416, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0)
%419 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %411, i8* %418)
br label %420
420: ; preds = %406
%421 = load i32, i32* %32
%422 = add nsw i32 %421, 1
store i32 %422, i32* %32
br label %400
423: ; preds = %400
br label %432
424: ; preds = %354
%425 = load i32*, i32** %15
%426 = getelementptr inbounds i32, i32* %425, i64 3
%427 = load i32, i32* %426
%428 = load i32*, i32** %15
%429 = getelementptr inbounds i32, i32* %428, i64 2
%430 = load i32, i32* %429
%431 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.6, i64 0, i64 0), i32 %427, i32 %430)
br label %432
432: ; preds = %424, %423
br label %433
433: ; preds = %432, %347
store x86_fp80 0xK00000000000000000000, x86_fp80* %38
%434 = load i32*, i32** %15
%435 = getelementptr inbounds i32, i32* %434, i64 2
%436 = load i32, i32* %435
%437 = icmp ne i32 %436, 2
br i1 %437, label %443, label %438
438: ; preds = %433
%439 = load i32*, i32** %15
%440 = getelementptr inbounds i32, i32* %439, i64 3
%441 = load i32, i32* %440
%442 = icmp ne i32 %441, 2
br i1 %442, label %443, label %649
443: ; preds = %438, %433
%444 = load i32*, i32** %22
%445 = load i32, i32* %444
%446 = icmp ne i32 %445, 0
br i1 %446, label %447, label %454
447: ; preds = %443
%448 = load i32*, i32** %22
%449 = load i32, i32* %448
%450 = icmp sge i32 %449, 2
%451 = zext i1 %450 to i64
%452 = select i1 %450, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0)
%453 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.7, i64 0, i64 0), i8* %452)
br label %454
454: ; preds = %447, %443
br label %455
455: ; preds = %626, %454
%456 = load i32*, i32** %17
%457 = load i32, i32* %31
%458 = sext i32 %457 to i64
%459 = getelementptr inbounds i32, i32* %456, i64 %458
%460 = load i32, i32* %459
store i32 %460, i32* %40
%461 = load i32*, i32** %18
%462 = load i32, i32* %30
%463 = sext i32 %462 to i64
%464 = getelementptr inbounds i32, i32* %461, i64 %463
%465 = load i32, i32* %464
store i32 %465, i32* %41
%466 = load i32, i32* %40
%467 = load i32, i32* %41
%468 = icmp sgt i32 %466, %467
br i1 %468, label %469, label %533
469: ; preds = %455
%470 = load i32*, i32** %17
%471 = load i32, i32* %31
%472 = add nsw i32 %471, 1
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds i32, i32* %470, i64 %473
%475 = load i32, i32* %474
store i32 %475, i32* %42
%476 = load i32, i32* %41
%477 = load i32, i32* %42
%478 = sub nsw i32 %476, %477
%479 = add nsw i32 %478, 1
%480 = sitofp i32 %479 to x86_fp80
%481 = load double*, double** %12
%482 = load i32, i32* %41
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds double, double* %481, i64 %483
%485 = load double, double* %484
%486 = fpext double %485 to x86_fp80
%487 = load double*, double** %12
%488 = load i32, i32* %42
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds double, double* %487, i64 %489
%491 = load double, double* %490
%492 = fpext double %491 to x86_fp80
%493 = fsub x86_fp80 %486, %492
%494 = load i32, i32* %40
%495 = load i32, i32* %42
%496 = sub nsw i32 %494, %495
%497 = sitofp i32 %496 to x86_fp80
%498 = fmul x86_fp80 %493, %497
%499 = load double*, double** %12
%500 = load i32, i32* %40
%501 = sext i32 %500 to i64
%502 = getelementptr inbounds double, double* %499, i64 %501
%503 = load double, double* %502
%504 = load double*, double** %12
%505 = load i32, i32* %42
%506 = sext i32 %505 to i64
%507 = getelementptr inbounds double, double* %504, i64 %506
%508 = load double, double* %507
%509 = fsub double %503, %508
%510 = fpext double %509 to x86_fp80
%511 = fdiv x86_fp80 %498, %510
%512 = fsub x86_fp80 %480, %511
store x86_fp80 %512, x86_fp80* %39
%513 = load i32, i32* %30
%514 = add nsw i32 %513, 1
store i32 %514, i32* %30
%515 = load x86_fp80, x86_fp80* %39
%516 = load x86_fp80, x86_fp80* %38
%517 = fcmp oge x86_fp80 %515, %516
br i1 %517, label %518, label %532
518: ; preds = %469
%519 = load x86_fp80, x86_fp80* %39
store x86_fp80 %519, x86_fp80* %38
%520 = load i32, i32* %31
%521 = add nsw i32 %520, 1
store i32 %521, i32* %28
%522 = load i32, i32* %30
%523 = sub nsw i32 %522, 1
store i32 %523, i32* %29
%524 = load i32*, i32** %22
%525 = load i32, i32* %524
%526 = icmp sge i32 %525, 2
br i1 %526, label %527, label %531
527: ; preds = %518
%528 = load i32, i32* %28
%529 = load i32, i32* %29
%530 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.9, i64 0, i64 0), i32 %528, i32 %529)
br label %531
531: ; preds = %527, %518
br label %532
532: ; preds = %531, %469
br label %596
533: ; preds = %455
%534 = load i32*, i32** %18
%535 = load i32, i32* %30
%536 = sub nsw i32 %535, 1
%537 = sext i32 %536 to i64
%538 = getelementptr inbounds i32, i32* %534, i64 %537
%539 = load i32, i32* %538
store i32 %539, i32* %43
%540 = load double*, double** %12
%541 = load i32, i32* %40
%542 = sext i32 %541 to i64
%543 = getelementptr inbounds double, double* %540, i64 %542
%544 = load double, double* %543
%545 = fpext double %544 to x86_fp80
%546 = load double*, double** %12
%547 = load i32, i32* %43
%548 = sext i32 %547 to i64
%549 = getelementptr inbounds double, double* %546, i64 %548
%550 = load double, double* %549
%551 = fpext double %550 to x86_fp80
%552 = fsub x86_fp80 %545, %551
%553 = load i32, i32* %41
%554 = load i32, i32* %43
%555 = sub nsw i32 %553, %554
%556 = sitofp i32 %555 to x86_fp80
%557 = fmul x86_fp80 %552, %556
%558 = load double*, double** %12
%559 = load i32, i32* %41
%560 = sext i32 %559 to i64
%561 = getelementptr inbounds double, double* %558, i64 %560
%562 = load double, double* %561
%563 = load double*, double** %12
%564 = load i32, i32* %43
%565 = sext i32 %564 to i64
%566 = getelementptr inbounds double, double* %563, i64 %565
%567 = load double, double* %566
%568 = fsub double %562, %567
%569 = fpext double %568 to x86_fp80
%570 = fdiv x86_fp80 %557, %569
%571 = load i32, i32* %40
%572 = load i32, i32* %43
%573 = sub nsw i32 %571, %572
%574 = sub nsw i32 %573, 1
%575 = sitofp i32 %574 to x86_fp80
%576 = fsub x86_fp80 %570, %575
store x86_fp80 %576, x86_fp80* %39
%577 = load i32, i32* %31
%578 = add nsw i32 %577, -1
store i32 %578, i32* %31
%579 = load x86_fp80, x86_fp80* %39
%580 = load x86_fp80, x86_fp80* %38
%581 = fcmp oge x86_fp80 %579, %580
br i1 %581, label %582, label %595
582: ; preds = %533
%583 = load x86_fp80, x86_fp80* %39
store x86_fp80 %583, x86_fp80* %38
%584 = load i32, i32* %31
%585 = add nsw i32 %584, 1
store i32 %585, i32* %28
%586 = load i32, i32* %30
store i32 %586, i32* %29
%587 = load i32*, i32** %22
%588 = load i32, i32* %587
%589 = icmp sge i32 %588, 2
br i1 %589, label %590, label %594
590: ; preds = %582
%591 = load i32, i32* %28
%592 = load i32, i32* %29
%593 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.10, i64 0, i64 0), i32 %591, i32 %592)
br label %594
594: ; preds = %590, %582
br label %595
595: ; preds = %594, %533
br label %596
596: ; preds = %595, %532
%597 = load i32, i32* %31
%598 = icmp slt i32 %597, 0
br i1 %598, label %599, label %600
599: ; preds = %596
store i32 0, i32* %31
br label %600
600: ; preds = %599, %596
%601 = load i32, i32* %30
%602 = load i32*, i32** %15
%603 = getelementptr inbounds i32, i32* %602, i64 3
%604 = load i32, i32* %603
%605 = icmp sgt i32 %601, %604
br i1 %605, label %606, label %610
606: ; preds = %600
%607 = load i32*, i32** %15
%608 = getelementptr inbounds i32, i32* %607, i64 3
%609 = load i32, i32* %608
store i32 %609, i32* %30
br label %610
610: ; preds = %606, %600
%611 = load i32*, i32** %22
%612 = load i32, i32* %611
%613 = icmp ne i32 %612, 0
br i1 %613, label %614, label %625
614: ; preds = %610
%615 = load i32*, i32** %22
%616 = load i32, i32* %615
%617 = icmp sge i32 %616, 2
br i1 %617, label %618, label %622
618: ; preds = %614
%619 = load i32, i32* %31
%620 = load i32, i32* %30
%621 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.11, i64 0, i64 0), i32 %619, i32 %620)
br label %624
622: ; preds = %614
%623 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.12, i64 0, i64 0))
br label %624
624: ; preds = %622, %618
br label %625
625: ; preds = %624, %610
br label %626
626: ; preds = %625
%627 = load i32*, i32** %17
%628 = load i32, i32* %31
%629 = sext i32 %628 to i64
%630 = getelementptr inbounds i32, i32* %627, i64 %629
%631 = load i32, i32* %630
%632 = load i32*, i32** %18
%633 = load i32, i32* %30
%634 = sext i32 %633 to i64
%635 = getelementptr inbounds i32, i32* %632, i64 %634
%636 = load i32, i32* %635
%637 = icmp ne i32 %631, %636
br i1 %637, label %455, label %638
638: ; preds = %626
%639 = load i32*, i32** %22
%640 = load i32, i32* %639
%641 = icmp ne i32 %640, 0
br i1 %641, label %642, label %648
642: ; preds = %638
%643 = load i32*, i32** %22
%644 = load i32, i32* %643
%645 = icmp slt i32 %644, 2
br i1 %645, label %646, label %648
646: ; preds = %642
%647 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %648
648: ; preds = %646, %642, %638
br label %670
649: ; preds = %438
%650 = load i32*, i32** %21
%651 = load i32, i32* %650
%652 = icmp ne i32 %651, 0
%653 = zext i1 %652 to i64
%654 = select i1 %652, double 0.000000e+00, double 1.000000e+00
%655 = fpext double %654 to x86_fp80
store x86_fp80 %655, x86_fp80* %38
%656 = load i32*, i32** %22
%657 = load i32, i32* %656
%658 = icmp ne i32 %657, 0
br i1 %658, label %659, label %669
659: ; preds = %649
%660 = load i32*, i32** %15
%661 = getelementptr inbounds i32, i32* %660, i64 3
%662 = load i32, i32* %661
%663 = load i32*, i32** %15
%664 = getelementptr inbounds i32, i32* %663, i64 2
%665 = load i32, i32* %664
%666 = load x86_fp80, x86_fp80* %38
%667 = fptrunc x86_fp80 %666 to double
%668 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.13, i64 0, i64 0), i32 %662, i32 %665, double %667)
br label %669
669: ; preds = %659, %649
br label %670
670: ; preds = %669, %648
%671 = load x86_fp80, x86_fp80* %38
%672 = load double*, double** %14
%673 = load double, double* %672
%674 = fpext double %673 to x86_fp80
%675 = fcmp olt x86_fp80 %671, %674
br i1 %675, label %676, label %677
676: ; preds = %670
br label %973
677: ; preds = %670
%678 = load i32*, i32** %22
%679 = load i32, i32* %678
%680 = icmp ne i32 %679, 0
br i1 %680, label %681, label %683
681: ; preds = %677
%682 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.14, i64 0, i64 0))
br label %683
683: ; preds = %681, %677
store i32 -1, i32* %45
store i32 -1, i32* %46
store double 0.000000e+00, double* %35
%684 = load i32, i32* %28
store i32 %684, i32* %33
br label %685
685: ; preds = %780, %683
%686 = load i32, i32* %33
%687 = load i32*, i32** %15
%688 = getelementptr inbounds i32, i32* %687, i64 2
%689 = load i32, i32* %688
%690 = icmp slt i32 %686, %689
br i1 %690, label %691, label %783
691: ; preds = %685
store double 1.000000e+00, double* %47
store i32 -1, i32* %48
%692 = load i32*, i32** %17
%693 = load i32, i32* %33
%694 = add nsw i32 %693, 1
%695 = sext i32 %694 to i64
%696 = getelementptr inbounds i32, i32* %692, i64 %695
%697 = load i32, i32* %696
store i32 %697, i32* %49
%698 = load i32*, i32** %17
%699 = load i32, i32* %33
%700 = sext i32 %699 to i64
%701 = getelementptr inbounds i32, i32* %698, i64 %700
%702 = load i32, i32* %701
store i32 %702, i32* %50
%703 = load i32, i32* %50
%704 = load i32, i32* %49
%705 = sub nsw i32 %703, %704
%706 = icmp sgt i32 %705, 1
br i1 %706, label %707, label %772
707: ; preds = %691
%708 = load double*, double** %12
%709 = load i32, i32* %50
%710 = sext i32 %709 to i64
%711 = getelementptr inbounds double, double* %708, i64 %710
%712 = load double, double* %711
%713 = load double*, double** %12
%714 = load i32, i32* %49
%715 = sext i32 %714 to i64
%716 = getelementptr inbounds double, double* %713, i64 %715
%717 = load double, double* %716
%718 = fcmp une double %712, %717
br i1 %718, label %719, label %772
719: ; preds = %707
%720 = load i32, i32* %50
%721 = load i32, i32* %49
%722 = sub nsw i32 %720, %721
%723 = sitofp i32 %722 to double
%724 = load double*, double** %12
%725 = load i32, i32* %50
%726 = sext i32 %725 to i64
%727 = getelementptr inbounds double, double* %724, i64 %726
%728 = load double, double* %727
%729 = load double*, double** %12
%730 = load i32, i32* %49
%731 = sext i32 %730 to i64
%732 = getelementptr inbounds double, double* %729, i64 %731
%733 = load double, double* %732
%734 = fsub double %728, %733
%735 = fdiv double %723, %734
store double %735, double* %51
%736 = load i32, i32* %49
store i32 %736, i32* %52
br label %737
737: ; preds = %768, %719
%738 = load i32, i32* %52
%739 = load i32, i32* %50
%740 = icmp sle i32 %738, %739
br i1 %740, label %741, label %771
741: ; preds = %737
%742 = load i32, i32* %52
%743 = load i32, i32* %49
%744 = sub nsw i32 %742, %743
%745 = add nsw i32 %744, 1
%746 = sitofp i32 %745 to double
%747 = load double*, double** %12
%748 = load i32, i32* %52
%749 = sext i32 %748 to i64
%750 = getelementptr inbounds double, double* %747, i64 %749
%751 = load double, double* %750
%752 = load double*, double** %12
%753 = load i32, i32* %49
%754 = sext i32 %753 to i64
%755 = getelementptr inbounds double, double* %752, i64 %754
%756 = load double, double* %755
%757 = fsub double %751, %756
%758 = load double, double* %51
%759 = fneg double %757
%760 = call double @llvm.fmuladd.f64(double %759, double %758, double %746)
store double %760, double* %53
%761 = load double, double* %47
%762 = load double, double* %53
%763 = fcmp olt double %761, %762
br i1 %763, label %764, label %767
764: ; preds = %741
%765 = load double, double* %53
store double %765, double* %47
%766 = load i32, i32* %52
store i32 %766, i32* %48
br label %767
767: ; preds = %764, %741
br label %768
768: ; preds = %767
%769 = load i32, i32* %52
%770 = add nsw i32 %769, 1
store i32 %770, i32* %52
br label %737
771: ; preds = %737
br label %772
772: ; preds = %771, %707, %691
%773 = load double, double* %35
%774 = load double, double* %47
%775 = fcmp olt double %773, %774
br i1 %775, label %776, label %779
776: ; preds = %772
%777 = load double, double* %47
store double %777, double* %35
%778 = load i32, i32* %48
store i32 %778, i32* %45
br label %779
779: ; preds = %776, %772
br label %780
780: ; preds = %779
%781 = load i32, i32* %33
%782 = add nsw i32 %781, 1
store i32 %782, i32* %33
br label %685
783: ; preds = %685
store double 0.000000e+00, double* %36
%784 = load i32, i32* %29
store i32 %784, i32* %33
br label %785
785: ; preds = %880, %783
%786 = load i32, i32* %33
%787 = load i32*, i32** %15
%788 = getelementptr inbounds i32, i32* %787, i64 3
%789 = load i32, i32* %788
%790 = icmp slt i32 %786, %789
br i1 %790, label %791, label %883
791: ; preds = %785
store double 1.000000e+00, double* %54
store i32 -1, i32* %55
%792 = load i32*, i32** %18
%793 = load i32, i32* %33
%794 = sext i32 %793 to i64
%795 = getelementptr inbounds i32, i32* %792, i64 %794
%796 = load i32, i32* %795
store i32 %796, i32* %56
%797 = load i32*, i32** %18
%798 = load i32, i32* %33
%799 = add nsw i32 %798, 1
%800 = sext i32 %799 to i64
%801 = getelementptr inbounds i32, i32* %797, i64 %800
%802 = load i32, i32* %801
store i32 %802, i32* %57
%803 = load i32, i32* %57
%804 = load i32, i32* %56
%805 = sub nsw i32 %803, %804
%806 = icmp sgt i32 %805, 1
br i1 %806, label %807, label %872
807: ; preds = %791
%808 = load double*, double** %12
%809 = load i32, i32* %57
%810 = sext i32 %809 to i64
%811 = getelementptr inbounds double, double* %808, i64 %810
%812 = load double, double* %811
%813 = load double*, double** %12
%814 = load i32, i32* %56
%815 = sext i32 %814 to i64
%816 = getelementptr inbounds double, double* %813, i64 %815
%817 = load double, double* %816
%818 = fcmp une double %812, %817
br i1 %818, label %819, label %872
819: ; preds = %807
%820 = load i32, i32* %57
%821 = load i32, i32* %56
%822 = sub nsw i32 %820, %821
%823 = sitofp i32 %822 to double
%824 = load double*, double** %12
%825 = load i32, i32* %57
%826 = sext i32 %825 to i64
%827 = getelementptr inbounds double, double* %824, i64 %826
%828 = load double, double* %827
%829 = load double*, double** %12
%830 = load i32, i32* %56
%831 = sext i32 %830 to i64
%832 = getelementptr inbounds double, double* %829, i64 %831
%833 = load double, double* %832
%834 = fsub double %828, %833
%835 = fdiv double %823, %834
store double %835, double* %58
%836 = load i32, i32* %56
store i32 %836, i32* %59
br label %837
837: ; preds = %868, %819
%838 = load i32, i32* %59
%839 = load i32, i32* %57
%840 = icmp sle i32 %838, %839
br i1 %840, label %841, label %871
841: ; preds = %837
%842 = load double*, double** %12
%843 = load i32, i32* %59
%844 = sext i32 %843 to i64
%845 = getelementptr inbounds double, double* %842, i64 %844
%846 = load double, double* %845
%847 = load double*, double** %12
%848 = load i32, i32* %56
%849 = sext i32 %848 to i64
%850 = getelementptr inbounds double, double* %847, i64 %849
%851 = load double, double* %850
%852 = fsub double %846, %851
%853 = load double, double* %58
%854 = load i32, i32* %59
%855 = load i32, i32* %56
%856 = sub nsw i32 %854, %855
%857 = sub nsw i32 %856, 1
%858 = sitofp i32 %857 to double
%859 = fneg double %858
%860 = call double @llvm.fmuladd.f64(double %852, double %853, double %859)
store double %860, double* %60
%861 = load double, double* %54
%862 = load double, double* %60
%863 = fcmp olt double %861, %862
br i1 %863, label %864, label %867
864: ; preds = %841
%865 = load double, double* %60
store double %865, double* %54
%866 = load i32, i32* %59
store i32 %866, i32* %55
br label %867
867: ; preds = %864, %841
br label %868
868: ; preds = %867
%869 = load i32, i32* %59
%870 = add nsw i32 %869, 1
store i32 %870, i32* %59
br label %837
871: ; preds = %837
br label %872
872: ; preds = %871, %807, %791
%873 = load double, double* %36
%874 = load double, double* %54
%875 = fcmp olt double %873, %874
br i1 %875, label %876, label %879
876: ; preds = %872
%877 = load double, double* %54
store double %877, double* %36
%878 = load i32, i32* %55
store i32 %878, i32* %46
br label %879
879: ; preds = %876, %872
br label %880
880: ; preds = %879
%881 = load i32, i32* %33
%882 = add nsw i32 %881, 1
store i32 %882, i32* %33
br label %785
883: ; preds = %785
%884 = load i32*, i32** %22
%885 = load i32, i32* %884
%886 = icmp ne i32 %885, 0
br i1 %886, label %887, label %891
887: ; preds = %883
%888 = load double, double* %35
%889 = load double, double* %36
%890 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.15, i64 0, i64 0), double %888, double %889)
br label %891
891: ; preds = %887, %883
%892 = load double, double* %36
%893 = load double, double* %35
%894 = fcmp ogt double %892, %893
br i1 %894, label %895, label %898
895: ; preds = %891
%896 = load double, double* %36
store double %896, double* %37
%897 = load i32, i32* %46
store i32 %897, i32* %44
br label %901
898: ; preds = %891
%899 = load double, double* %35
store double %899, double* %37
%900 = load i32, i32* %45
store i32 %900, i32* %44
br label %901
901: ; preds = %898, %895
%902 = load double*, double** %14
%903 = load double, double* %902
%904 = load double, double* %37
%905 = fcmp olt double %903, %904
br i1 %905, label %906, label %917
906: ; preds = %901
%907 = load double, double* %37
%908 = load double*, double** %14
store double %907, double* %908
%909 = load i32*, i32** %22
%910 = load i32, i32* %909
%911 = icmp ne i32 %910, 0
br i1 %911, label %912, label %916
912: ; preds = %906
%913 = load double, double* %37
%914 = load i32, i32* %44
%915 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.16, i64 0, i64 0), double %913, i32 %914)
br label %916
916: ; preds = %912, %906
br label %924
917: ; preds = %901
%918 = load i32*, i32** %22
%919 = load i32, i32* %918
%920 = icmp ne i32 %919, 0
br i1 %920, label %921, label %923
921: ; preds = %917
%922 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %923
923: ; preds = %921, %917
br label %924
924: ; preds = %923, %916
%925 = load i32*, i32** %15
%926 = getelementptr inbounds i32, i32* %925, i64 0
%927 = load i32, i32* %926
%928 = load i32*, i32** %17
%929 = load i32, i32* %28
%930 = sext i32 %929 to i64
%931 = getelementptr inbounds i32, i32* %928, i64 %930
%932 = load i32, i32* %931
%933 = icmp eq i32 %927, %932
br i1 %933, label %934, label %957
934: ; preds = %924
%935 = load i32*, i32** %15
%936 = getelementptr inbounds i32, i32* %935, i64 1
%937 = load i32, i32* %936
%938 = load i32*, i32** %18
%939 = load i32, i32* %29
%940 = sext i32 %939 to i64
%941 = getelementptr inbounds i32, i32* %938, i64 %940
%942 = load i32, i32* %941
%943 = icmp eq i32 %937, %942
br i1 %943, label %944, label %957
944: ; preds = %934
%945 = load i32*, i32** %22
%946 = load i32, i32* %945
%947 = icmp ne i32 %946, 0
br i1 %947, label %948, label %956
948: ; preds = %944
%949 = load i32*, i32** %15
%950 = getelementptr inbounds i32, i32* %949, i64 0
%951 = load i32, i32* %950
%952 = load i32*, i32** %15
%953 = getelementptr inbounds i32, i32* %952, i64 1
%954 = load i32, i32* %953
%955 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.17, i64 0, i64 0), i32 %951, i32 %954)
br label %956
956: ; preds = %948, %944
br label %972
957: ; preds = %934, %924
%958 = load i32*, i32** %17
%959 = load i32, i32* %28
%960 = sext i32 %959 to i64
%961 = getelementptr inbounds i32, i32* %958, i64 %960
%962 = load i32, i32* %961
%963 = load i32*, i32** %15
%964 = getelementptr inbounds i32, i32* %963, i64 0
store i32 %962, i32* %964
%965 = load i32*, i32** %18
%966 = load i32, i32* %29
%967 = sext i32 %966 to i64
%968 = getelementptr inbounds i32, i32* %965, i64 %967
%969 = load i32, i32* %968
%970 = load i32*, i32** %15
%971 = getelementptr inbounds i32, i32* %970, i64 1
store i32 %969, i32* %971
br label %274
972: ; preds = %956
br label %973
973: ; preds = %972, %676, %119
%974 = load i32, i32* %23
%975 = mul nsw i32 2, %974
%976 = sitofp i32 %975 to double
%977 = load double*, double** %14
%978 = load double, double* %977
%979 = fdiv double %978, %976
store double %979, double* %977
br label %980
980: ; preds = %973, %87, %66
ret void
}

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