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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double dlamch_(char *);
int /*<<< orphan*/ mc64ud_(int *, int *, int *, int *, int *, int *, int *,
                           int *, int *, int *, int *, int *, int *, int *,
                           int *);
int mc64sd_(int *n, int *ne, int *ip, int *irn, double *a, int *iperm,
            int *numx, int *w, int *len, int *lenl, int *lenh, int *fc, int *iw,
            int *iw4) {
  int i__1, i__2, i__3, i__4;
  int i__, j, k, l, ii, mod, cnt, num;
  double bval, bmin, bmax, rinf;
  int nval, wlen, idum1, idum2, idum3;
  extern int mc64qd_(int *, int *, int *, int *, int *, double *, int *,
                     double *),
      mc64ud_(int *, int *, int *, int *, int *, int *, int *, int *, int *,
              int *, int *, int *, int *, int *, int *);
  --iw4;
  --iw;
  --fc;
  --lenh;
  --lenl;
  --len;
  --w;
  --iperm;
  --ip;
  --a;
  --irn;
  rinf = dlamch_("Overflow");
  i__1 = *n;
  for (j = 1; j <= i__1; ++j) {
    fc[j] = j;
    iw[j] = 0;
    len[j] = ip[j + 1] - ip[j];
  }
  cnt = 1;
  mod = 1;
  *numx = 0;
  mc64ud_(&cnt, &mod, n, &irn[1], ne, &ip[1], &len[1], &fc[1], &iw[1], numx, n,
          &iw4[1], &iw4[*n + 1], &iw4[(*n << 1) + 1], &iw4[*n * 3 + 1]);
  num = *numx;
  if (num != *n) {
    bmax = rinf;
  } else {
    bmax = rinf;
    i__1 = *n;
    for (j = 1; j <= i__1; ++j) {
      bval = 0.f;
      i__2 = ip[j + 1] - 1;
      for (k = ip[j]; k <= i__2; ++k) {
        if (a[k] > bval) {
          bval = a[k];
        }
      }
      if (bval < bmax) {
        bmax = bval;
      }
    }
    bmax *= 1.001f;
  }
  bval = 0.f;
  bmin = 0.f;
  wlen = 0;
  i__1 = *n;
  for (j = 1; j <= i__1; ++j) {
    l = ip[j + 1] - ip[j];
    lenh[j] = l;
    len[j] = l;
    i__2 = ip[j + 1] - 1;
    for (k = ip[j]; k <= i__2; ++k) {
      if (a[k] < bmax) {
        goto L46;
      }
    }
    k = ip[j + 1];
  L46:
    lenl[j] = k - ip[j];
    if (lenl[j] == l) {
      goto L48;
    }
    ++wlen;
    w[wlen] = j;
  L48:;
  }
  i__1 = *ne;
  for (idum1 = 1; idum1 <= i__1; ++idum1) {
    if (num == *numx) {
      i__2 = *n;
      for (i__ = 1; i__ <= i__2; ++i__) {
        iperm[i__] = iw[i__];
      }
      i__2 = *ne;
      for (idum2 = 1; idum2 <= i__2; ++idum2) {
        bmin = bval;
        if (bmax == bmin) {
          goto L99;
        }
        mc64qd_(&ip[1], &lenl[1], &len[1], &w[1], &wlen, &a[1], &nval, &bval);
        if (nval <= 1) {
          goto L99;
        }
        k = 1;
        i__3 = *n;
        for (idum3 = 1; idum3 <= i__3; ++idum3) {
          if (k > wlen) {
            goto L71;
          }
          j = w[k];
          i__4 = ip[j] + lenl[j];
          for (ii = ip[j] + len[j] - 1; ii >= i__4; --ii) {
            if (a[ii] >= bval) {
              goto L60;
            }
            i__ = irn[ii];
            if (iw[i__] != j) {
              goto L55;
            }
            iw[i__] = 0;
            --num;
            fc[*n - num] = j;
          L55:;
          }
        L60:
          lenh[j] = len[j];
          len[j] = ii - ip[j] + 1;
          if (lenl[j] == lenh[j]) {
            w[k] = w[wlen];
            --wlen;
          } else {
            ++k;
          }
        }
      L71:
        if (num < *numx) {
          goto L81;
        }
      }
    L81:
      mod = 1;
    } else {
      bmax = bval;
      mc64qd_(&ip[1], &len[1], &lenh[1], &w[1], &wlen, &a[1], &nval, &bval);
      if (nval == 0 || bval == bmin) {
        goto L99;
      }
      k = 1;
      i__2 = *n;
      for (idum3 = 1; idum3 <= i__2; ++idum3) {
        if (k > wlen) {
          goto L88;
        }
        j = w[k];
        i__3 = ip[j] + lenh[j] - 1;
        for (ii = ip[j] + len[j]; ii <= i__3; ++ii) {
          if (a[ii] < bval) {
            goto L86;
          }
        }
      L86:
        lenl[j] = len[j];
        len[j] = ii - ip[j];
        if (lenl[j] == lenh[j]) {
          w[k] = w[wlen];
          --wlen;
        } else {
          ++k;
        }
      }
    L88:
      mod = 0;
    }
    ++cnt;
    mc64ud_(&cnt, &mod, n, &irn[1], ne, &ip[1], &len[1], &fc[1], &iw[1], &num,
            numx, &iw4[1], &iw4[*n + 1], &iw4[(*n << 1) + 1], &iw4[*n * 3 + 1]);
  }
L99:
  if (*numx == *n) {
    goto L1000;
  }
  i__1 = *n;
  for (j = 1; j <= i__1; ++j) {
    w[j] = 0;
  }
  k = 0;
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    if (iperm[i__] == 0) {
      ++k;
      iw[k] = i__;
    } else {
      j = iperm[i__];
      w[j] = i__;
    }
  }
  k = 0;
  i__1 = *n;
  for (j = 1; j <= i__1; ++j) {
    if (w[j] != 0) {
      goto L320;
    }
    ++k;
    idum1 = iw[k];
    iperm[idum1] = j;
  L320:;
  }
L1000:
  return 0;
}


x86 assembly (clang, -O0):
<mc64sd_>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x30(%rbp)
mov    %rsi,-0x38(%rbp)
mov    %rdx,-0x40(%rbp)
mov    %rcx,-0x48(%rbp)
mov    %r8,-0x50(%rbp)
mov    %r9,-0x58(%rbp)
mov    0x48(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x48(%rbp)
mov    0x40(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x40(%rbp)
mov    0x38(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x38(%rbp)
mov    0x30(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x30(%rbp)
mov    0x28(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x28(%rbp)
mov    0x20(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x20(%rbp)
mov    0x18(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x18(%rbp)
mov    -0x58(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x58(%rbp)
mov    -0x40(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x40(%rbp)
mov    -0x50(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x48(%rbp)
lea    0xe01(%rip),%rdi
call   1050 <dlamch_@plt>
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x1,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     1281 <mc64sd_+0x151>
mov    -0x70(%rbp),%edx
mov    0x38(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x40(%rbp),%rax
movslq -0x70(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
mov    -0x70(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x40(%rbp),%rax
movslq -0x70(%rbp),%rcx
sub    (%rax,%rcx,4),%edx
mov    0x20(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1224 <mc64sd_+0xf4>
movl   $0x1,-0x84(%rbp)
movl   $0x1,-0x80(%rbp)
mov    0x10(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x30(%rbp),%rdx
mov    -0x48(%rbp),%rcx
add    $0x4,%rcx
mov    -0x38(%rbp),%r8
mov    -0x40(%rbp),%r9
add    $0x4,%r9
mov    0x20(%rbp),%rax
add    $0x4,%rax
mov    0x38(%rbp),%r13
add    $0x4,%r13
mov    0x40(%rbp),%r12
add    $0x4,%r12
mov    0x10(%rbp),%r15
mov    -0x30(%rbp),%r14
mov    0x48(%rbp),%rbx
add    $0x4,%rbx
mov    0x48(%rbp),%r11
mov    -0x30(%rbp),%rsi
mov    (%rsi),%esi
add    $0x1,%esi
movslq %esi,%rsi
shl    $0x2,%rsi
add    %rsi,%r11
mov    0x48(%rbp),%r10
mov    -0x30(%rbp),%rsi
mov    (%rsi),%esi
shl    $0x1,%esi
add    $0x1,%esi
movslq %esi,%rsi
shl    $0x2,%rsi
add    %rsi,%r10
mov    0x48(%rbp),%rsi
mov    -0x30(%rbp),%rdi
imul   $0x3,(%rdi),%edi
add    $0x1,%edi
movslq %edi,%rdi
shl    $0x2,%rdi
add    %rdi,%rsi
mov    %rsi,-0xc8(%rbp)
lea    -0x84(%rbp),%rdi
lea    -0x80(%rbp),%rsi
mov    %rax,(%rsp)
mov    -0xc8(%rbp),%rax
mov    %r13,0x8(%rsp)
mov    %r12,0x10(%rsp)
mov    %r15,0x18(%rsp)
mov    %r14,0x20(%rsp)
mov    %rbx,0x28(%rsp)
mov    %r11,0x30(%rsp)
mov    %r10,0x38(%rsp)
mov    %rax,0x40(%rsp)
call   1030 <mc64ud_@plt>
mov    0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    -0x30(%rbp),%rcx
cmp    (%rcx),%eax
je     13a2 <mc64sd_+0x272>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    14a1 <mc64sd_+0x371>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x1,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     1489 <mc64sd_+0x359>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    -0x70(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x60(%rbp),%eax
jg     144c <mc64sd_+0x31c>
mov    -0x50(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x90(%rbp),%xmm0
ff
jbe    1439 <mc64sd_+0x309>
mov    -0x50(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
jmp    143e <mc64sd_+0x30e>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    13fd <mc64sd_+0x2cd>
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0xa0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1476 <mc64sd_+0x346>
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    147b <mc64sd_+0x34b>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    13c2 <mc64sd_+0x292>
movsd  0xb6f(%rip),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0xb0(%rbp)
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x1,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     15f6 <mc64sd_+0x4c6>
mov    -0x40(%rbp),%rax
mov    -0x70(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0x70(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%edx
mov    0x30(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x78(%rbp),%edx
mov    0x20(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
mov    -0x70(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x60(%rbp),%eax
jg     157e <mc64sd_+0x44e>
mov    -0x50(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    156b <mc64sd_+0x43b>
jmp    1591 <mc64sd_+0x461>
jmp    1570 <mc64sd_+0x440>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    153b <mc64sd_+0x40b>
mov    -0x40(%rbp),%rax
mov    -0x70(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%edx
mov    -0x40(%rbp),%rax
movslq -0x70(%rbp),%rcx
sub    (%rax,%rcx,4),%edx
mov    0x28(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x78(%rbp),%eax
jne    15c3 <mc64sd_+0x493>
jmp    15e3 <mc64sd_+0x4b3>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0x70(%rbp),%edx
mov    0x18(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    15e8 <mc64sd_+0x4b8>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    14d1 <mc64sd_+0x3a1>
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x1,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     1c0f <mc64sd_+0xadf>
mov    -0x88(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jne    191f <mc64sd_+0x7ef>
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x60(%rbp)
movl   $0x1,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x60(%rbp),%eax
jg     166a <mc64sd_+0x53a>
mov    0x40(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x58(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    163a <mc64sd_+0x50a>
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x60(%rbp)
movl   $0x1,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x60(%rbp),%eax
jg     190e <mc64sd_+0x7de>
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
ucomisd -0x98(%rbp),%xmm0
ff
jne    16bd <mc64sd_+0x58d>
jp     16bd <mc64sd_+0x58d>
jmp    1c14 <mc64sd_+0xae4>
mov    -0x40(%rbp),%rdi
add    $0x4,%rdi
mov    0x28(%rbp),%rsi
add    $0x4,%rsi
mov    0x20(%rbp),%rdx
add    $0x4,%rdx
mov    0x18(%rbp),%rcx
add    $0x4,%rcx
mov    -0x50(%rbp),%r9
add    $0x8,%r9
lea    -0xb0(%rbp),%r8
lea    -0xac(%rbp),%r10
lea    -0x90(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1040 <mc64qd_@plt>
cmpl   $0x1,-0xac(%rbp)
jg     171a <mc64sd_+0x5ea>
jmp    1c14 <mc64sd_+0xae4>
movl   $0x1,-0x74(%rbp)
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x64(%rbp)
movl   $0x1,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    -0x64(%rbp),%eax
jg     18d9 <mc64sd_+0x7a9>
mov    -0x74(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jle    1757 <mc64sd_+0x627>
jmp    18de <mc64sd_+0x7ae>
mov    0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x70(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x28(%rbp),%rcx
movslq -0x70(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x68(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x20(%rbp),%rcx
movslq -0x70(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x68(%rbp),%eax
jl     1837 <mc64sd_+0x707>
mov    -0x50(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x90(%rbp),%xmm0
ff
jb     17c6 <mc64sd_+0x696>
jmp    183c <mc64sd_+0x70c>
mov    -0x48(%rbp),%rax
movslq -0x7c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x6c(%rbp)
mov    0x40(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x70(%rbp),%eax
je     17ed <mc64sd_+0x6bd>
jmp    1824 <mc64sd_+0x6f4>
mov    0x40(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x88(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x88(%rbp)
mov    -0x70(%rbp),%edx
mov    0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rcx),%ecx
sub    -0x88(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1829 <mc64sd_+0x6f9>
mov    -0x7c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x7c(%rbp)
jmp    179a <mc64sd_+0x66a>
jmp    183c <mc64sd_+0x70c>
mov    0x20(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x30(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x7c(%rbp),%edx
mov    -0x40(%rbp),%rax
movslq -0x70(%rbp),%rcx
sub    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    0x20(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x30(%rbp),%rcx
movslq -0x70(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    18b7 <mc64sd_+0x787>
mov    0x18(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xb0(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xb0(%rbp)
jmp    18c0 <mc64sd_+0x790>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    18c5 <mc64sd_+0x795>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    1734 <mc64sd_+0x604>
jmp    18de <mc64sd_+0x7ae>
mov    -0x88(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    18f5 <mc64sd_+0x7c5>
jmp    1913 <mc64sd_+0x7e3>
jmp    18fa <mc64sd_+0x7ca>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    167d <mc64sd_+0x54d>
jmp    1913 <mc64sd_+0x7e3>
movl   $0x1,-0x80(%rbp)
jmp    1b16 <mc64sd_+0x9e6>
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x40(%rbp),%rdi
add    $0x4,%rdi
mov    0x20(%rbp),%rsi
add    $0x4,%rsi
mov    0x30(%rbp),%rdx
add    $0x4,%rdx
mov    0x18(%rbp),%rcx
add    $0x4,%rcx
mov    -0x50(%rbp),%r9
add    $0x8,%r9
lea    -0xb0(%rbp),%r8
lea    -0xac(%rbp),%r10
lea    -0x90(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1040 <mc64qd_@plt>
cmpl   $0x0,-0xac(%rbp)
je     19a3 <mc64sd_+0x873>
movsd  -0x90(%rbp),%xmm0
ff
ucomisd -0x98(%rbp),%xmm0
ff
jne    19a8 <mc64sd_+0x878>
jp     19a8 <mc64sd_+0x878>
jmp    1c14 <mc64sd_+0xae4>
movl   $0x1,-0x74(%rbp)
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x60(%rbp)
movl   $0x1,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    -0x60(%rbp),%eax
jg     1b0a <mc64sd_+0x9da>
mov    -0x74(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jle    19e5 <mc64sd_+0x8b5>
jmp    1b0f <mc64sd_+0x9df>
mov    0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x70(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x30(%rbp),%rcx
movslq -0x70(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x20(%rbp),%rcx
movslq -0x70(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x64(%rbp),%eax
jg     1a6b <mc64sd_+0x93b>
mov    -0x50(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1a58 <mc64sd_+0x928>
jmp    1a70 <mc64sd_+0x940>
jmp    1a5d <mc64sd_+0x92d>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1a28 <mc64sd_+0x8f8>
jmp    1a70 <mc64sd_+0x940>
mov    0x20(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x28(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x7c(%rbp),%edx
mov    -0x40(%rbp),%rax
movslq -0x70(%rbp),%rcx
sub    (%rax,%rcx,4),%edx
mov    0x20(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x30(%rbp),%rcx
movslq -0x70(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1ae8 <mc64sd_+0x9b8>
mov    0x18(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xb0(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xb0(%rbp)
jmp    1af1 <mc64sd_+0x9c1>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1af6 <mc64sd_+0x9c6>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    19c2 <mc64sd_+0x892>
jmp    1b0f <mc64sd_+0x9df>
movl   $0x0,-0x80(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x48(%rbp),%rcx
add    $0x4,%rcx
mov    -0x38(%rbp),%r8
mov    -0x40(%rbp),%r9
add    $0x4,%r9
mov    0x20(%rbp),%rax
add    $0x4,%rax
mov    0x38(%rbp),%r13
add    $0x4,%r13
mov    0x40(%rbp),%r12
add    $0x4,%r12
mov    0x10(%rbp),%r14
mov    0x48(%rbp),%rbx
add    $0x4,%rbx
mov    0x48(%rbp),%r11
mov    -0x30(%rbp),%rsi
mov    (%rsi),%esi
add    $0x1,%esi
movslq %esi,%rsi
shl    $0x2,%rsi
add    %rsi,%r11
mov    0x48(%rbp),%r10
mov    -0x30(%rbp),%rsi
mov    (%rsi),%esi
shl    $0x1,%esi
add    $0x1,%esi
movslq %esi,%rsi
shl    $0x2,%rsi
add    %rsi,%r10
mov    0x48(%rbp),%rsi
mov    -0x30(%rbp),%rdi
imul   $0x3,(%rdi),%edi
add    $0x1,%edi
movslq %edi,%rdi
shl    $0x2,%rdi
add    %rdi,%rsi
mov    %rsi,-0xd0(%rbp)
lea    -0x84(%rbp),%rdi
lea    -0x80(%rbp),%rsi
lea    -0x88(%rbp),%r15
mov    %rax,(%rsp)
mov    -0xd0(%rbp),%rax
mov    %r13,0x8(%rsp)
mov    %r12,0x10(%rsp)
mov    %r15,0x18(%rsp)
mov    %r14,0x20(%rsp)
mov    %rbx,0x28(%rsp)
mov    %r11,0x30(%rsp)
mov    %r10,0x38(%rsp)
mov    %rax,0x40(%rsp)
call   1030 <mc64ud_@plt>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1609 <mc64sd_+0x4d9>
jmp    1c14 <mc64sd_+0xae4>
mov    0x10(%rbp),%rax
mov    (%rax),%eax
mov    -0x30(%rbp),%rcx
cmp    (%rcx),%eax
jne    1c2b <mc64sd_+0xafb>
jmp    1d61 <mc64sd_+0xc31>
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x1,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     1c64 <mc64sd_+0xb34>
mov    0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1c3b <mc64sd_+0xb0b>
movl   $0x0,-0x74(%rbp)
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x1,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     1ce4 <mc64sd_+0xbb4>
mov    -0x58(%rbp),%rax
movslq -0x6c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1cb5 <mc64sd_+0xb85>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x6c(%rbp),%edx
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1cd1 <mc64sd_+0xba1>
mov    -0x58(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%edx
mov    0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1cd6 <mc64sd_+0xba6>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1c7b <mc64sd_+0xb4b>
movl   $0x0,-0x74(%rbp)
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x1,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     1d5c <mc64sd_+0xc2c>
mov    0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1d1e <mc64sd_+0xbee>
jmp    1d49 <mc64sd_+0xc19>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xb4(%rbp)
mov    -0x70(%rbp),%edx
mov    -0x58(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1d4e <mc64sd_+0xc1e>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1cfb <mc64sd_+0xbcb>
jmp    1d61 <mc64sd_+0xc31>
xor    %eax,%eax
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<mc64sd_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r9,0x48(%rsp)
mov    %r8,%r13
mov    %rcx,%r12
mov    %rdx,0x8(%rsp)
mov    %rsi,0x58(%rsp)
mov    %rdi,%rbx
mov    0xf8(%rsp),%rax
mov    0xf0(%rsp),%rcx
add    $0xfffffffffffffffc,%rax
mov    %rax,0x70(%rsp)
lea    -0x4(%rcx),%r14
lea    0xeab(%rip),%rdi
call   1060 <dlamch_@plt>
mov    %rbx,0x20(%rsp)
mov    (%rbx),%edx
test   %edx,%edx
jle    1454 <mc64sd_+0x314>
lea    0x1(%rdx),%r15
mov    $0x1,%r9d
cmp    $0x4,%rdx
jb     1394 <mc64sd_+0x254>
mov    0xf0(%rsp),%rsi
lea    (%rsi,%r15,4),%rbp
add    $0xfffffffffffffffc,%rbp
mov    0xe8(%rsp),%rcx
cmp    %rcx,%rbp
seta   0x28(%rsp)
lea    (%rcx,%r15,4),%rdi
add    $0xfffffffffffffffc,%rdi
cmp    %rsi,%rdi
seta   0x10(%rsp)
mov    0xd0(%rsp),%r8
lea    (%r8,%r15,4),%r11
add    $0xfffffffffffffffc,%r11
cmp    %rcx,%r11
seta   %bl
cmp    %r8,%rdi
seta   0x38(%rsp)
mov    0x8(%rsp),%rax
lea    (%rax,%r15,4),%rsi
cmp    %rcx,%rsi
seta   %r10b
cmp    %rax,%rdi
seta   0x60(%rsp)
mov    0xf0(%rsp),%rcx
cmp    %rcx,%r11
seta   %dil
cmp    %r8,%rbp
seta   0x18(%rsp)
cmp    %rcx,%rsi
seta   %cl
cmp    %rax,%rbp
seta   %bpl
cmp    %r8,%rsi
seta   %sil
cmp    %rax,%r11
seta   %r8b
mov    0x10(%rsp),%al
test   %al,0x28(%rsp)
jne    1394 <mc64sd_+0x254>
and    0x38(%rsp),%bl
jne    1394 <mc64sd_+0x254>
and    0x60(%rsp),%r10b
jne    1394 <mc64sd_+0x254>
and    0x18(%rsp),%dil
jne    1394 <mc64sd_+0x254>
and    %bpl,%cl
jne    1394 <mc64sd_+0x254>
and    %r8b,%sil
mov    0xf0(%rsp),%rcx
mov    0xe8(%rsp),%rbx
jne    139c <mc64sd_+0x25c>
mov    %edx,%r9d
and    $0xfffffffc,%r9d
lea    -0x4(%r9),%rsi
mov    %rsi,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     1f26 <mc64sd_+0xde6>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
movdqa 0xd35(%rip),%xmm6
xor    %esi,%esi
pxor   %xmm1,%xmm1
movdqa 0xd37(%rip),%xmm2
movdqa 0xd3f(%rip),%xmm3
mov    0x8(%rsp),%rax
mov    0xd0(%rsp),%rbp
xchg   %ax,%ax
movdqu %xmm6,(%rbx,%rsi,4)
movdqu %xmm1,(%rcx,%rsi,4)
movdqu (%rax,%rsi,4),%xmm4
movdqu 0x4(%rax,%rsi,4),%xmm5
psubd  %xmm4,%xmm5
movdqu %xmm5,0x0(%rbp,%rsi,4)
movdqa %xmm6,%xmm4
paddd  %xmm2,%xmm4
movdqu %xmm4,0x10(%rbx,%rsi,4)
movdqu %xmm1,0x10(%rcx,%rsi,4)
movdqu 0x10(%rax,%rsi,4),%xmm4
movdqu 0x14(%rax,%rsi,4),%xmm5
psubd  %xmm4,%xmm5
movdqu %xmm5,0x10(%rbp,%rsi,4)
add    $0x8,%rsi
paddd  %xmm3,%xmm6
add    $0xfffffffffffffffe,%rdi
jne    12f0 <mc64sd_+0x1b0>
test   $0x1,%r8b
je     1387 <mc64sd_+0x247>
shl    $0x2,%rsi
or     $0x4,%rsi
movdqu %xmm6,-0x4(%rbx,%rsi,1)
pxor   %xmm1,%xmm1
movdqu %xmm1,(%r14,%rsi,1)
mov    0x8(%rsp),%rax
movdqu -0x4(%rax,%rsi,1),%xmm2
movdqu (%rax,%rsi,1),%xmm1
psubd  %xmm2,%xmm1
mov    0xd0(%rsp),%rax
movdqu %xmm1,-0x4(%rax,%rsi,1)
cmp    %r9,%rdx
je     1454 <mc64sd_+0x314>
or     $0x1,%r9
mov    0xe8(%rsp),%rbx
mov    %r9,%rdx
not    %rdx
test   $0x1,%r15b
jne    13d4 <mc64sd_+0x294>
mov    %r9d,-0x4(%rbx,%r9,4)
movl   $0x0,(%r14,%r9,4)
mov    0x8(%rsp),%rax
mov    (%rax,%r9,4),%esi
sub    -0x4(%rax,%r9,4),%esi
mov    0xd0(%rsp),%rax
mov    %esi,-0x4(%rax,%r9,4)
add    $0x1,%r9
add    %r15,%rdx
je     1454 <mc64sd_+0x314>
mov    0xd0(%rsp),%rax
lea    (%rax,%r9,4),%rdx
mov    0x8(%rsp),%rax
lea    (%rax,%r9,4),%rsi
mov    0xf0(%rsp),%rax
lea    (%rax,%r9,4),%rdi
mov    0xe8(%rsp),%rax
lea    (%rax,%r9,4),%rbp
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
lea    (%r9,%rbx,1),%rax
mov    %eax,-0x4(%rbp,%rbx,4)
movl   $0x0,-0x4(%rdi,%rbx,4)
mov    (%rsi,%rbx,4),%ecx
sub    -0x4(%rsi,%rbx,4),%ecx
mov    %ecx,-0x4(%rdx,%rbx,4)
add    $0x1,%eax
mov    %eax,0x0(%rbp,%rbx,4)
movl   $0x0,(%rdi,%rbx,4)
mov    0x4(%rsi,%rbx,4),%eax
sub    (%rsi,%rbx,4),%eax
mov    %eax,(%rdx,%rbx,4)
lea    (%r9,%rbx,1),%rax
add    $0x2,%rax
add    $0x2,%rbx
cmp    %r15,%rax
jne    1410 <mc64sd_+0x2d0>
movsd  %xmm0,0x18(%rsp)
movl   $0x1,0x40(%rsp)
movl   $0x1,0x44(%rsp)
mov    0xc0(%rsp),%rax
movl   $0x0,(%rax)
mov    %rax,%r11
mov    0x20(%rsp),%rbp
movslq 0x0(%rbp),%rax
mov    0x70(%rsp),%rdx
lea    0x4(%rdx,%rax,4),%r10
lea    0x1(%rax,%rax,1),%ecx
movslq %ecx,%rcx
lea    (%rdx,%rcx,4),%rbx
lea    (%rax,%rax,2),%rax
lea    (%rdx,%rax,4),%rax
add    $0x4,%rax
sub    $0x8,%rsp
lea    0x48(%rsp),%rdi
lea    0x4c(%rsp),%rsi
mov    %rbp,%rdx
mov    %r12,%rcx
mov    0x60(%rsp),%r8
mov    0x10(%rsp),%r15
mov    %r15,%r9
push   %rax
push   %rbx
push   %r10
push   0x118(%rsp)
push   %rbp
push   %r11
push   0x128(%rsp)
push   0x128(%rsp)
mov    0x118(%rsp),%rbx
push   %rbx
call   1040 <mc64ud_@plt>
add    $0x50,%rsp
mov    0xc0(%rsp),%rax
mov    (%rax),%r8d
mov    %r8d,0x2c(%rsp)
mov    0x0(%rbp),%r10d
cmp    %r10d,%r8d
jne    15ea <mc64sd_+0x4aa>
test   %r8d,%r8d
jle    1602 <mc64sd_+0x4c2>
lea    0x1(%r8),%r9
mov    (%r15),%esi
mov    $0x1,%edi
movsd  0x18(%rsp),%xmm2
jmp    1541 <mc64sd_+0x401>
xchg   %ax,%ax
movdqa %xmm1,%xmm2
minsd  %xmm0,%xmm2
cmp    %r9,%rdi
je     15f2 <mc64sd_+0x4b2>
movapd %xmm2,%xmm0
mov    %esi,%eax
mov    (%r15,%rdi,4),%esi
add    $0x1,%rdi
pxor   %xmm1,%xmm1
cmp    %esi,%eax
jge    1530 <mc64sd_+0x3f0>
movslq %esi,%rbp
movslq %eax,%rbx
mov    %esi,%edx
sub    %eax,%edx
mov    %rbx,%rax
not    %rax
add    %rbp,%rax
and    $0x3,%rdx
je     15a1 <mc64sd_+0x461>
xorpd  %xmm2,%xmm2
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x8(%r13,%rbx,8),%xmm1
maxsd  %xmm2,%xmm1
add    $0x1,%rbx
movapd %xmm1,%xmm2
add    $0xffffffffffffffff,%rdx
jne    1580 <mc64sd_+0x440>
cmp    $0x3,%rax
jae    15b0 <mc64sd_+0x470>
jmp    1530 <mc64sd_+0x3f0>
pxor   %xmm1,%xmm1
cmp    $0x3,%rax
jb     1530 <mc64sd_+0x3f0>
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%r13,%rbx,8),%xmm2
maxsd  %xmm1,%xmm2
movsd  0x0(%r13,%rbx,8),%xmm1
maxsd  %xmm2,%xmm1
movsd  0x8(%r13,%rbx,8),%xmm2
maxsd  %xmm1,%xmm2
movsd  0x10(%r13,%rbx,8),%xmm1
maxsd  %xmm2,%xmm1
add    $0x4,%rbx
cmp    %rbx,%rbp
jne    15b0 <mc64sd_+0x470>
jmp    1530 <mc64sd_+0x3f0>
movsd  0x18(%rsp),%xmm2
jmp    1610 <mc64sd_+0x4d0>
movq   %xmm1,0x30(%rsp)
mov    0xd0(%rsp),%rbx
jmp    1608 <mc64sd_+0x4c8>
movsd  0x18(%rsp),%xmm2
mulsd  0xa20(%rip),%xmm2
mov    0xc8(%rsp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x10(%rsp)
movq   $0x0,0x30(%rsp)
movl   $0x0,0x4(%rsp)
test   %r10d,%r10d
jle    16f6 <mc64sd_+0x5b6>
add    $0x1,%r10
lea    -0x8(%r13),%r9
xor    %esi,%esi
mov    $0x1,%edi
jmp    1664 <mc64sd_+0x524>
nopl   0x0(%rax)
mov    0xd0(%rsp),%rbx
mov    %rcx,%rdi
cmp    %r10,%rcx
je     16f6 <mc64sd_+0x5b6>
mov    (%r15,%rdi,4),%ebp
sub    -0x4(%r15,%rdi,4),%ebp
mov    0xe0(%rsp),%rax
mov    %ebp,-0x4(%rax,%rdi,4)
mov    %ebp,-0x4(%rbx,%rdi,4)
mov    -0x4(%r15,%rdi,4),%edx
mov    (%r15,%rdi,4),%ebx
cmp    %ebx,%edx
jge    16c2 <mc64sd_+0x582>
movslq %edx,%rax
lea    (%r9,%rax,8),%rcx
mov    %edx,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
ucomisd (%rcx),%xmm2
ja     16c0 <mc64sd_+0x580>
add    $0x1,%eax
add    $0x8,%rcx
cmp    %eax,%ebx
jne    16a0 <mc64sd_+0x560>
jmp    16c2 <mc64sd_+0x582>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %eax,%ebx
lea    0x1(%rdi),%rcx
sub    %edx,%ebx
mov    0xd8(%rsp),%rax
mov    %ebx,-0x4(%rax,%rdi,4)
cmp    %ebp,%ebx
je     1650 <mc64sd_+0x510>
movslq %esi,%rax
lea    0x1(%rsi),%edx
mov    %edx,0x4(%rsp)
mov    0x10(%rsp),%rsi
mov    %edi,0x4(%rsi,%rax,4)
mov    %edx,%esi
jmp    1650 <mc64sd_+0x510>
mov    0x58(%rsp),%rax
mov    (%rax),%eax
mov    %eax,0x68(%rsp)
test   %eax,%eax
jle    1d5c <mc64sd_+0xc1c>
mov    0x48(%rsp),%rbx
lea    -0x4(%rbx),%rax
mov    %rax,0x80(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x78(%rsp)
movl   $0x1,0x54(%rsp)
mov    0xc0(%rsp),%rax
cmp    (%rax),%r8d
jne    17b0 <mc64sd_+0x670>
mov    0x20(%rsp),%rax
mov    (%rax),%edx
test   %edx,%edx
mov    0xf0(%rsp),%rax
jle    1a67 <mc64sd_+0x927>
lea    0x1(%rdx),%r8
mov    $0x1,%ecx
cmp    $0x8,%rdx
jb     1a00 <mc64sd_+0x8c0>
lea    (%r14,%r8,4),%rsi
cmp    %rbx,%rsi
jbe    1781 <mc64sd_+0x641>
mov    0x80(%rsp),%rsi
lea    (%rsi,%r8,4),%rsi
cmp    %rax,%rsi
ja     1a00 <mc64sd_+0x8c0>
mov    %edx,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ebp
and    $0x3,%ebp
cmp    $0x18,%rdi
jae    193f <mc64sd_+0x7ff>
xor    %edi,%edi
jmp    19ac <mc64sd_+0x86c>
nopl   0x0(%rax,%rax,1)
movsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
mov    %r15,%rdi
mov    0xd0(%rsp),%rsi
mov    0xe0(%rsp),%rdx
mov    0xc8(%rsp),%rcx
lea    0x4(%rsp),%r8
mov    %r13,%r9
lea    0x30(%rsp),%rax
push   %rax
lea    0x44(%rsp),%rax
push   %rax
call   1050 <mc64qd_@plt>
add    $0x10,%rsp
cmpl   $0x0,0x3c(%rsp)
je     1d5c <mc64sd_+0xc1c>
movsd  0x30(%rsp),%xmm0
ucomisd 0x78(%rsp),%xmm0
jne    1813 <mc64sd_+0x6d3>
jnp    1d5c <mc64sd_+0xc1c>
mov    0x20(%rsp),%rax
mov    (%rax),%r9d
xor    %r8d,%r8d
test   %r9d,%r9d
jle    1cb7 <mc64sd_+0xb77>
mov    0x4(%rsp),%r15d
test   %r15d,%r15d
mov    0x10(%rsp),%rdi
jle    1935 <mc64sd_+0x7f5>
mov    $0x1,%esi
mov    $0x1,%r10d
cs nopw 0x0(%rax,%rax,1)
nop
movslq %r10d,%r11
movslq (%rdi,%r11,4),%rbx
mov    0x8(%rsp),%rax
mov    -0x4(%rax,%rbx,4),%edx
mov    0xe0(%rsp),%rax
mov    -0x4(%rax,%rbx,4),%ebp
mov    0xd0(%rsp),%rax
mov    -0x4(%rax,%rbx,4),%ecx
lea    (%rcx,%rdx,1),%eax
cmp    %ebp,%ecx
jge    18c7 <mc64sd_+0x787>
add    %edx,%ebp
movslq %eax,%rdi
movslq %ebp,%rbp
lea    (%rcx,%rdx,1),%eax
add    $0x1,%eax
cmp    %ebp,%eax
cmovle %ebp,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
ucomisd -0x8(%r13,%rdi,8),%xmm0
ja     18c0 <mc64sd_+0x780>
add    $0x1,%rdi
cmp    %rbp,%rdi
jl     18a0 <mc64sd_+0x760>
jmp    18c2 <mc64sd_+0x782>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %edi,%eax
mov    0x10(%rsp),%rdi
mov    0xd8(%rsp),%rdx
mov    %ecx,-0x4(%rdx,%rbx,4)
mov    0x8(%rsp),%rcx
sub    -0x4(%rcx,%rbx,4),%eax
mov    0xd0(%rsp),%rcx
mov    %eax,-0x4(%rcx,%rbx,4)
mov    -0x4(%rdx,%rbx,4),%eax
mov    0xe0(%rsp),%rcx
cmp    -0x4(%rcx,%rbx,4),%eax
jne    1920 <mc64sd_+0x7e0>
movslq %r15d,%r15
mov    (%rdi,%r15,4),%eax
mov    %eax,(%rdi,%r11,4)
add    $0xffffffff,%r15d
mov    %r15d,0x4(%rsp)
cmp    %r9d,%esi
jl     1929 <mc64sd_+0x7e9>
jmp    1935 <mc64sd_+0x7f5>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r10d
cmp    %r9d,%esi
jge    1935 <mc64sd_+0x7f5>
add    $0x1,%esi
cmp    %r15d,%r10d
jle    1850 <mc64sd_+0x710>
mov    0x8(%rsp),%r15
jmp    1cb7 <mc64sd_+0xb77>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rax,%rdi,4),%xmm0
movups 0x10(%rax,%rdi,4),%xmm1
movups %xmm0,(%rbx,%rdi,4)
movups %xmm1,0x10(%rbx,%rdi,4)
movups 0x20(%rax,%rdi,4),%xmm0
movups 0x30(%rax,%rdi,4),%xmm1
movups %xmm0,0x20(%rbx,%rdi,4)
movups %xmm1,0x30(%rbx,%rdi,4)
movups 0x40(%rax,%rdi,4),%xmm0
movups 0x50(%rax,%rdi,4),%xmm1
movups %xmm0,0x40(%rbx,%rdi,4)
movups %xmm1,0x50(%rbx,%rdi,4)
movupd 0x60(%rax,%rdi,4),%xmm0
movdqu 0x70(%rax,%rdi,4),%xmm1
movupd %xmm0,0x60(%rbx,%rdi,4)
movdqu %xmm1,0x70(%rbx,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1950 <mc64sd_+0x810>
test   %rbp,%rbp
je     19ef <mc64sd_+0x8af>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x0(,%rdi,4),%rsi
or     $0x4,%rsi
movupd (%r14,%rsi,1),%xmm0
movdqu 0x10(%r14,%rsi,1),%xmm1
movupd %xmm0,-0x4(%rbx,%rsi,1)
movdqu %xmm1,0xc(%rbx,%rsi,1)
add    $0x8,%rdi
add    $0xffffffffffffffff,%rbp
jne    19c0 <mc64sd_+0x880>
cmp    %rcx,%rdx
je     1a67 <mc64sd_+0x927>
or     $0x1,%rcx
nopl   0x0(%rax,%rax,1)
mov    %r8d,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
not    %rdx
add    %r8,%rdx
and    $0x3,%rsi
je     1a32 <mc64sd_+0x8f2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r14,%rcx,4),%edi
mov    %edi,-0x4(%rbx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1a20 <mc64sd_+0x8e0>
cmp    $0x3,%rdx
jb     1a67 <mc64sd_+0x927>
nopl   0x0(%rax,%rax,1)
mov    -0x4(%rax,%rcx,4),%edx
mov    %edx,-0x4(%rbx,%rcx,4)
mov    (%rax,%rcx,4),%edx
mov    %edx,(%rbx,%rcx,4)
mov    0x4(%rax,%rcx,4),%edx
mov    %edx,0x4(%rbx,%rcx,4)
mov    0x8(%rax,%rcx,4),%edx
mov    %edx,0x8(%rbx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1a40 <mc64sd_+0x900>
mov    0x58(%rsp),%rax
mov    (%rax),%eax
mov    %eax,0x6c(%rsp)
test   %eax,%eax
movsd  %xmm2,0x18(%rsp)
jle    1cb1 <mc64sd_+0xb71>
mov    $0x1,%eax
mov    0xd0(%rsp),%rbx
nopl   (%rax)
mov    %rax,0x60(%rsp)
movsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x78(%rsp)
ucomisd %xmm0,%xmm2
jne    1aad <mc64sd_+0x96d>
jnp    1d5c <mc64sd_+0xc1c>
mov    %r15,%rdi
mov    0xd8(%rsp),%rsi
mov    %rbx,%rdx
mov    0xc8(%rsp),%rcx
lea    0x4(%rsp),%r8
mov    %r13,%r9
lea    0x30(%rsp),%rax
push   %rax
lea    0x44(%rsp),%rax
push   %rax
call   1050 <mc64qd_@plt>
movsd  0x28(%rsp),%xmm2
add    $0x10,%rsp
cmpl   $0x2,0x3c(%rsp)
jl     1d5c <mc64sd_+0xc1c>
mov    0x20(%rsp),%rax
mov    (%rax),%ecx
mov    0x2c(%rsp),%eax
mov    %ecx,0x38(%rsp)
test   %ecx,%ecx
mov    0x10(%rsp),%rdi
jle    1c8b <mc64sd_+0xb4b>
mov    0x4(%rsp),%r11d
test   %r11d,%r11d
jle    1c8b <mc64sd_+0xb4b>
mov    $0x1,%r8d
movsd  0x30(%rsp),%xmm0
mov    $0x1,%ecx
nopl   0x0(%rax)
mov    %ecx,0x28(%rsp)
movslq %ecx,%r10
mov    (%rdi,%r10,4),%edi
movslq %edi,%rcx
mov    -0x4(%r15,%rcx,4),%ebp
mov    0xd8(%rsp),%rdx
mov    -0x4(%rdx,%rcx,4),%esi
mov    -0x4(%rbx,%rcx,4),%edx
lea    (%rdx,%rbp,1),%ebx
add    $0xffffffff,%ebx
cmp    %esi,%edx
jle    1bf0 <mc64sd_+0xab0>
add    %ebp,%esi
movslq %ebx,%rbp
movslq %esi,%rdx
cmp    %edx,%ebp
mov    %edx,%r15d
cmovl  %ebp,%r15d
add    $0xffffffff,%r15d
add    $0x1,%rbp
jmp    1b8c <mc64sd_+0xa4c>
nopl   0x0(%rax)
add    $0xffffffff,%ebx
add    $0xffffffffffffffff,%rbp
cmp    %rdx,%rbp
jle    1c00 <mc64sd_+0xac0>
movsd  -0x10(%r13,%rbp,8),%xmm1
ucomisd %xmm0,%xmm1
jae    1c03 <mc64sd_+0xac3>
movslq -0x8(%r12,%rbp,4),%rsi
cmp    %edi,(%r14,%rsi,4)
jne    1b80 <mc64sd_+0xa40>
movl   $0x0,(%r14,%rsi,4)
cltq
add    $0xffffffffffffffff,%rax
mov    %eax,0x2c(%rsp)
mov    0x20(%rsp),%rsi
movslq (%rsi),%rsi
sub    %rax,%rsi
mov    %r13,%r9
mov    %r14,%r13
mov    %r12,%r14
mov    0xe8(%rsp),%r12
mov    %edi,-0x4(%r12,%rsi,4)
mov    %r14,%r12
mov    %r13,%r14
mov    %r9,%r13
jmp    1b80 <mc64sd_+0xa40>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0xd0(%rsp),%rsi
jmp    1c14 <mc64sd_+0xad4>
nopw   0x0(%rax,%rax,1)
mov    %r15d,%ebx
mov    0xd0(%rsp),%rsi
mov    -0x4(%rsi,%rcx,4),%edx
mov    0x8(%rsp),%r15
mov    0x10(%rsp),%rdi
mov    0xe0(%rsp),%rbp
mov    %edx,-0x4(%rbp,%rcx,4)
sub    -0x4(%r15,%rcx,4),%ebx
add    $0x1,%ebx
mov    %ebx,-0x4(%rsi,%rcx,4)
mov    0xd8(%rsp),%rdx
mov    -0x4(%rdx,%rcx,4),%edx
cmp    -0x4(%rbp,%rcx,4),%edx
mov    %rsi,%rbx
jne    1c70 <mc64sd_+0xb30>
movslq %r11d,%r11
mov    (%rdi,%r11,4),%ecx
mov    %ecx,(%rdi,%r10,4)
add    $0xffffffff,%r11d
mov    %r11d,0x4(%rsp)
mov    0x28(%rsp),%ecx
cmp    0x38(%rsp),%r8d
jl     1c7e <mc64sd_+0xb3e>
jmp    1c8b <mc64sd_+0xb4b>
nopw   0x0(%rax,%rax,1)
mov    0x28(%rsp),%ecx
add    $0x1,%ecx
cmp    0x38(%rsp),%r8d
jge    1c8b <mc64sd_+0xb4b>
add    $0x1,%r8d
cmp    %r11d,%ecx
jle    1b30 <mc64sd_+0x9f0>
mov    $0x1,%r8d
mov    0xc0(%rsp),%rcx
cmp    (%rcx),%eax
jl     1cb7 <mc64sd_+0xb77>
mov    0x60(%rsp),%rcx
lea    0x1(%rcx),%eax
cmp    0x6c(%rsp),%ecx
jl     1a90 <mc64sd_+0x950>
jmp    1cb7 <mc64sd_+0xb77>
mov    $0x1,%r8d
addl   $0x1,0x40(%rsp)
mov    %r8d,0x44(%rsp)
mov    0x20(%rsp),%rdx
movslq (%rdx),%rax
mov    0x70(%rsp),%rsi
lea    0x4(%rsi,%rax,4),%rbp
lea    0x1(%rax,%rax,1),%ecx
movslq %ecx,%rcx
lea    (%rsi,%rcx,4),%rbx
lea    (%rax,%rax,2),%rax
lea    (%rsi,%rax,4),%rax
add    $0x4,%rax
sub    $0x8,%rsp
lea    0x48(%rsp),%rdi
lea    0x4c(%rsp),%rsi
mov    %r12,%rcx
mov    0x60(%rsp),%r8
mov    %r15,%r9
push   %rax
push   %rbx
push   %rbp
push   0x118(%rsp)
push   0xe8(%rsp)
lea    0x5c(%rsp),%rax
push   %rax
push   0x128(%rsp)
push   0x128(%rsp)
push   0x118(%rsp)
call   1040 <mc64ud_@plt>
add    $0x50,%rsp
mov    0x54(%rsp),%eax
cmp    0x68(%rsp),%eax
movsd  0x18(%rsp),%xmm2
je     1d5c <mc64sd_+0xc1c>
addl   $0x1,0x54(%rsp)
mov    0x2c(%rsp),%r8d
mov    0x48(%rsp),%rbx
jmp    172c <mc64sd_+0x5ec>
mov    0x20(%rsp),%rax
mov    (%rax),%edx
mov    0xc0(%rsp),%rax
cmp    %edx,(%rax)
je     1e99 <mc64sd_+0xd59>
test   %edx,%edx
jle    1e99 <mc64sd_+0xd59>
shl    $0x2,%rdx
mov    0xc8(%rsp),%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x20(%rsp),%rax
mov    (%rax),%r8d
test   %r8d,%r8d
jle    1e99 <mc64sd_+0xd59>
cmp    $0x1,%r8d
jne    1dc3 <mc64sd_+0xc83>
mov    $0x1,%edx
mov    $0x1,%ecx
mov    0x48(%rsp),%r10
test   $0x1,%r8b
jne    1e44 <mc64sd_+0xd04>
jmp    1e5d <mc64sd_+0xd1d>
mov    %r8d,%r9d
and    $0xfffffffe,%r9d
xor    %edx,%edx
mov    $0x1,%ecx
mov    $0x2,%edi
xor    %ebp,%ebp
mov    0x48(%rsp),%r10
mov    0x10(%rsp),%r11
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x4(%r10,%rcx,4),%ebx
lea    0x1(%rdx),%eax
test   %ebx,%ebx
cmove  %eax,%ebx
mov    %r11,%rsi
cmove  %r14,%rsi
cmove  %eax,%edx
movslq %ebx,%rax
lea    -0x1(%rdi),%ebx
mov    %ebx,(%rsi,%rax,4)
mov    (%r10,%rcx,4),%eax
lea    0x1(%rdx),%esi
test   %eax,%eax
cmove  %esi,%eax
mov    %r11,%rbx
cmove  %r14,%rbx
cmove  %esi,%edx
cltq
mov    %edi,(%rbx,%rax,4)
add    $0x2,%rcx
add    $0x2,%rbp
add    $0x2,%edi
cmp    %r9,%rbp
jne    1df0 <mc64sd_+0xcb0>
add    $0x1,%edx
test   $0x1,%r8b
je     1e5d <mc64sd_+0xd1d>
mov    -0x4(%r10,%rcx,4),%eax
test   %eax,%eax
cmovne %eax,%edx
mov    0x10(%rsp),%rax
cmove  %r14,%rax
movslq %edx,%rdx
mov    %ecx,(%rax,%rdx,4)
mov    0x20(%rsp),%rax
mov    (%rax),%r8d
test   %r8d,%r8d
jle    1e99 <mc64sd_+0xd59>
cmp    $0x1,%r8d
jne    1ead <mc64sd_+0xd6d>
xor    %edx,%edx
mov    $0x1,%ecx
test   $0x1,%r8b
je     1e99 <mc64sd_+0xd59>
mov    0x10(%rsp),%rax
cmpl   $0x0,(%rax,%rcx,4)
jne    1e99 <mc64sd_+0xd59>
movslq %edx,%rax
movslq 0x4(%r14,%rax,4),%rax
mov    0x48(%rsp),%rdx
mov    %ecx,-0x4(%rdx,%rax,4)
xor    %eax,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r8d,%esi
and    $0xfffffffe,%esi
neg    %rsi
xor    %edx,%edx
mov    $0x1,%ecx
mov    $0x2,%edi
mov    0x48(%rsp),%rax
jmp    1ee5 <mc64sd_+0xda5>
nopl   0x0(%rax)
add    $0x2,%edi
lea    (%rsi,%rcx,1),%rbp
add    $0x2,%rbp
add    $0x2,%rcx
cmp    $0x1,%rbp
je     1e77 <mc64sd_+0xd37>
mov    0xc8(%rsp),%rbp
cmpl   $0x0,-0x4(%rbp,%rcx,4)
jne    1f06 <mc64sd_+0xdc6>
movslq %edx,%rbp
add    $0x1,%edx
movslq 0x4(%r14,%rbp,4),%rbp
lea    -0x1(%rdi),%ebx
mov    %ebx,-0x4(%rax,%rbp,4)
mov    0xc8(%rsp),%rbp
cmpl   $0x0,0x0(%rbp,%rcx,4)
jne    1ed0 <mc64sd_+0xd90>
movslq %edx,%rbp
add    $0x1,%edx
movslq 0x4(%r14,%rbp,4),%rbp
mov    %edi,-0x4(%rax,%rbp,4)
jmp    1ed0 <mc64sd_+0xd90>
movdqa 0xd2(%rip),%xmm6
xor    %esi,%esi
test   $0x1,%r8b
jne    134d <mc64sd_+0x20d>
jmp    1387 <mc64sd_+0x247>

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

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