int mc64ad_(int *job, int *n, int *ne, int *ip, int *irn, double *a, int *num,
            int *cperm, int *liw, int *iw, int *ldw, double *dw, int *icntl,
            int *info) {
  int i__1, i__2;
  double d__1, d__2;
  double log(double);
  int i__, j, k;
  double fact, rinf;
  extern int mc21ad_(int *, int *, int *, int *, int *, int *, int *, int *),
      mc64bd_(int *, int *, int *, int *, double *, int *, int *, int *, int *,
              int *, int *, double *),
      mc64rd_(int *, int *, int *, int *, double *),
      mc64sd_(int *, int *, int *, int *, double *, int *, int *, int *, int *,
              int *, int *, int *, int *, int *),
      mc64wd_(int *, int *, int *, int *, double *, int *, int *, int *, int *,
              int *, int *, int *, double *, double *);
  --cperm;
  --ip;
  --a;
  --irn;
  --iw;
  --dw;
  --icntl;
  --info;
  rinf = dlamch_("Overflow");
  if (*job < 1 || *job > 5) {
    info[1] = -1;
    info[2] = *job;
    if (icntl[1] >= 0) {
      printf(" ****** Error in MC64A/AD. INFO(1) = %2d", info[1],
             " because JOB = %d\n", *job);
    }
    goto L99;
  }
  if (*n < 1) {
    info[1] = -2;
    info[2] = *n;
    if (icntl[1] >= 0) {
      printf(" ****** Error in MC64A/AD. INFO(1) = %2d", info[1],
             " because N = %d\n", *job);
    }
    goto L99;
  }
  if (*ne < 1) {
    info[1] = -3;
    info[2] = *ne;
    if (icntl[1] >= 0) {
      printf(" ****** Error in MC64A/AD. INFO(1) = %2d", info[1],
             " because NE = %d\n", *job);
    }
    goto L99;
  }
  if (*job == 1) {
    k = *n * 5;
  }
  if (*job == 2) {
    k = *n << 2;
  }
  if (*job == 3) {
    k = *n * 10 + *ne;
  }
  if (*job == 4) {
    k = *n * 5;
  }
  if (*job == 5) {
    k = *n * 5;
  }
  if (*liw < k) {
    info[1] = -4;
    info[2] = k;
    if (icntl[1] >= 0) {
      printf(" ****** Error in MC64A/AD. INFO(1) = %2d", info[1],
             " LIW too small, must be at least %8d\n", k);
    }
    goto L99;
  }
  if (*job > 1) {
    if (*job == 2) {
      k = *n;
    }
    if (*job == 3) {
      k = *ne;
    }
    if (*job == 4) {
      k = (*n << 1) + *ne;
    }
    if (*job == 5) {
      k = *n * 3 + *ne;
    }
    if (*ldw < k) {
      info[1] = -5;
      info[2] = k;
      if (icntl[1] >= 0) {
        printf(" ****** Error in MC64A/AD. INFO(1) = %2d", info[1],
               " LDW too small, must be at least %8d\n", k);
      }
      goto L99;
    }
  }
  if (icntl[4] == 0) {
    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
      iw[i__] = 0;
    }
    i__1 = *n;
    for (j = 1; j <= i__1; ++j) {
      i__2 = ip[j + 1] - 1;
      for (k = ip[j]; k <= i__2; ++k) {
        i__ = irn[k];
        if (i__ < 1 || i__ > *n) {
          info[1] = -6;
          info[2] = j;
          if (icntl[1] >= 0) {
            printf(" ****** Error in MC64A/AD. INFO(1) = %2d", info[1],
                   " Column %8d", j,
                   " contains an entry with invalid row index %8d\n", i__);
          }
          goto L99;
        }
        if (iw[i__] == j) {
          info[1] = -7;
          info[2] = j;
          if (icntl[1] >= 0) {
            printf(" ****** Error in MC64A/AD. INFO(1) = %2d", info[1],
                   "        Column %8d", j,
                   " contains two or more entries with row index %8d\n", i__);
          }
          goto L99;
        } else {
          iw[i__] = j;
        }
      }
    }
  }
  if (icntl[3] >= 0) {
    printf("  ****** Input parameters for MC64A/AD: JOB = %8d,"
           " N = %d, NE = %8d\n",
           *job, *n, *ne);
    printf(" IP(1:N+1)   = ");
    for (j = 1; j <= (*n + 1); ++j) {
      printf("%8d", ip[j]);
      if (j % 8 == 0)
        printf("\n");
    }
    printf("\n IRN(1:NE) = ");
    for (j = 1; j <= (*ne); ++j) {
      printf("%8d", irn[j]);
      if (j % 8 == 0)
        printf("\n");
    }
    printf("\n");
    if (*job > 1) {
      printf(" A(1:NE)     = ");
      for (j = 1; j <= (*ne); ++j) {
        printf("%f14.4", a[j]);
        if (j % 4 == 0)
          printf("\n");
      }
      printf("\n");
    }
  }
  for (i__ = 1; i__ <= 10; ++i__) {
    info[i__] = 0;
  }
  if (*job == 1) {
    i__1 = *n;
    for (j = 1; j <= i__1; ++j) {
      iw[j] = ip[j + 1] - ip[j];
    }
    printf(" ****** Warning from MC64A/AD. Need to link mc21ad.\n");
    goto L90;
  }
  if (*job == 2) {
    mc64bd_(n, ne, &ip[1], &irn[1], &a[1], &cperm[1], num, &iw[1], &iw[*n + 1],
            &iw[(*n << 1) + 1], &iw[*n * 3 + 1], &dw[1]);
    goto L90;
  }
  if (*job == 3) {
    i__1 = *ne;
    for (k = 1; k <= i__1; ++k) {
      iw[k] = irn[k];
      dw[k] = (d__1 = a[k], ((d__1) >= 0) ? (d__1) : -(d__1));
    }
    mc64rd_(n, ne, &ip[1], &iw[1], &dw[1]);
    mc64sd_(n, ne, &ip[1], &iw[1], &dw[1], &cperm[1], num, &iw[*ne + 1],
            &iw[*ne + *n + 1], &iw[*ne + (*n << 1) + 1], &iw[*ne + *n * 3 + 1],
            &iw[*ne + (*n << 2) + 1], &iw[*ne + *n * 5 + 1],
            &iw[*ne + *n * 6 + 1]);
    goto L90;
  }
  if (*job == 4) {
    i__1 = *n;
    for (j = 1; j <= i__1; ++j) {
      fact = 0.;
      i__2 = ip[j + 1] - 1;
      for (k = ip[j]; k <= i__2; ++k) {
        if ((d__1 = a[k], ((d__1) >= 0) ? (d__1) : -(d__1)) > fact) {
          fact = (d__2 = a[k], ((d__2) >= 0) ? (d__2) : -(d__2));
        }
      }
      i__2 = ip[j + 1] - 1;
      for (k = ip[j]; k <= i__2; ++k) {
        dw[(*n << 1) + k] =
            fact - (d__1 = a[k], ((d__1) >= 0) ? (d__1) : -(d__1));
      }
    }
    mc64wd_(n, ne, &ip[1], &irn[1], &dw[(*n << 1) + 1], &cperm[1], num, &iw[1],
            &iw[*n + 1], &iw[(*n << 1) + 1], &iw[*n * 3 + 1],
            &iw[(*n << 2) + 1], &dw[1], &dw[*n + 1]);
    goto L90;
  }
  if (*job == 5) {
    i__1 = *n;
    for (j = 1; j <= i__1; ++j) {
      fact = 0.;
      i__2 = ip[j + 1] - 1;
      for (k = ip[j]; k <= i__2; ++k) {
        dw[*n * 3 + k] = (d__1 = a[k], ((d__1) >= 0) ? (d__1) : -(d__1));
        if (dw[*n * 3 + k] > fact) {
          fact = dw[*n * 3 + k];
        }
      }
      dw[(*n << 1) + j] = fact;
      if (fact != 0.) {
        fact = log(fact);
      } else {
        fact = rinf / *n;
      }
      i__2 = ip[j + 1] - 1;
      for (k = ip[j]; k <= i__2; ++k) {
        if (dw[*n * 3 + k] != 0.) {
          dw[*n * 3 + k] = fact - log(dw[*n * 3 + k]);
        } else {
          dw[*n * 3 + k] = rinf / *n;
        }
      }
    }
    mc64wd_(n, ne, &ip[1], &irn[1], &dw[*n * 3 + 1], &cperm[1], num, &iw[1],
            &iw[*n + 1], &iw[(*n << 1) + 1], &iw[*n * 3 + 1],
            &iw[(*n << 2) + 1], &dw[1], &dw[*n + 1]);
    if (*num == *n) {
      i__1 = *n;
      for (j = 1; j <= i__1; ++j) {
        if (dw[(*n << 1) + j] != 0.) {
          dw[*n + j] -= log(dw[(*n << 1) + j]);
        } else {
          dw[*n + j] = 0.;
        }
      }
    }
    fact = log(rinf) * .5f;
    i__1 = *n;
    for (j = 1; j <= i__1; ++j) {
      if (dw[j] < fact && dw[*n + j] < fact) {
        goto L86;
      }
      info[1] = 2;
      goto L90;
    L86:;
    }
  }
L90:
  if (info[1] == 0 && *num < *n) {
    info[1] = 1;
    if (icntl[2] >= 0) {
      printf(" ****** Warning from MC64A/AD. INFO(1) = %2d", info[1],
             " The matrix is structurally singular.\n");
    }
  }
  if (info[1] == 2) {
    if (icntl[2] >= 0) {
      printf(" ****** Warning from MC64A/AD. INFO(1) = %2d\n", info[1],
             "        Some scaling factors may be too large.\n");
    }
  }
  if (icntl[3] >= 0) {
    printf(" ****** Output parameters for MC64A/AD: INFO(1:2)  = %8d%8d\n",
           info[1], info[2]);
    printf(" NUM        = ", *num);
    printf(" CPERM(1:N) = ");
    for (j = 1; j <= *n; ++j) {
      printf("%8d", cperm[j]);
      if (j % 8 == 0)
        printf("\n");
    }
    if (*job == 5) {
      printf("\n DW(1:N)    = ");
      for (j = 1; j <= *n; ++j) {
        printf("%11.3f", dw[j]);
        if (j % 5 == 0)
          printf("\n");
      }
      printf("\n DW(N+1:2N) = ");
      for (j = 1; j <= *n; ++j) {
        printf("%11.3f", dw[*n + j]);
        if (j % 5 == 0)
          printf("\n");
      }
      printf("\n");
    }
  }
L99:
  return 0;
}


x86 assembly (clang, -O0):
<mc64ad_>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%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    0x18(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x18(%rbp)
mov    -0x48(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x48(%rbp)
mov    -0x58(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x58(%rbp)
mov    -0x50(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x50(%rbp)
mov    0x28(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x28(%rbp)
mov    0x38(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x38(%rbp)
mov    0x40(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x40(%rbp)
mov    0x48(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x48(%rbp)
lea    0x1de5(%rip),%rdi
mov    $0x0,%al
call   1070 <dlamch_@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x30(%rbp),%rax
cmpl   $0x1,(%rax)
jl     1250 <mc64ad_+0xe0>
mov    -0x30(%rbp),%rax
cmpl   $0x5,(%rax)
jle    129d <mc64ad_+0x12d>
mov    0x48(%rbp),%rax
movl   $0xffffffff,0x4(%rax)
mov    -0x30(%rbp),%rax
mov    (%rax),%ecx
mov    0x48(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    0x40(%rbp),%rax
cmpl   $0x0,0x4(%rax)
jl     1298 <mc64ad_+0x128>
mov    0x48(%rbp),%rax
mov    0x4(%rax),%esi
mov    -0x30(%rbp),%rax
mov    (%rax),%ecx
lea    0x1d87(%rip),%rdi
lea    0x1da9(%rip),%rdx
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2697 <mc64ad_+0x1527>
mov    -0x38(%rbp),%rax
cmpl   $0x1,(%rax)
jge    12f7 <mc64ad_+0x187>
mov    0x48(%rbp),%rax
movl   $0xfffffffe,0x4(%rax)
mov    -0x38(%rbp),%rax
mov    (%rax),%ecx
mov    0x48(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    0x40(%rbp),%rax
cmpl   $0x0,0x4(%rax)
jl     12f2 <mc64ad_+0x182>
mov    0x48(%rbp),%rax
mov    0x4(%rax),%esi
mov    -0x30(%rbp),%rax
mov    (%rax),%ecx
lea    0x1d2d(%rip),%rdi
lea    0x1d62(%rip),%rdx
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2697 <mc64ad_+0x1527>
mov    -0x40(%rbp),%rax
cmpl   $0x1,(%rax)
jge    1351 <mc64ad_+0x1e1>
mov    0x48(%rbp),%rax
movl   $0xfffffffd,0x4(%rax)
mov    -0x40(%rbp),%rax
mov    (%rax),%ecx
mov    0x48(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    0x40(%rbp),%rax
cmpl   $0x0,0x4(%rax)
jl     134c <mc64ad_+0x1dc>
mov    0x48(%rbp),%rax
mov    0x4(%rax),%esi
mov    -0x30(%rbp),%rax
mov    (%rax),%ecx
lea    0x1cd3(%rip),%rdi
lea    0x1d19(%rip),%rdx
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2697 <mc64ad_+0x1527>
mov    -0x30(%rbp),%rax
cmpl   $0x1,(%rax)
jne    1368 <mc64ad_+0x1f8>
mov    -0x38(%rbp),%rax
imul   $0x5,(%rax),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x30(%rbp),%rax
cmpl   $0x2,(%rax)
jne    1381 <mc64ad_+0x211>
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
shl    $0x2,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x30(%rbp),%rax
cmpl   $0x3,(%rax)
jne    139e <mc64ad_+0x22e>
mov    -0x38(%rbp),%rax
imul   $0xa,(%rax),%eax
mov    -0x40(%rbp),%rcx
add    (%rcx),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x30(%rbp),%rax
cmpl   $0x4,(%rax)
jne    13b5 <mc64ad_+0x245>
mov    -0x38(%rbp),%rax
imul   $0x5,(%rax),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x30(%rbp),%rax
cmpl   $0x5,(%rax)
jne    13cc <mc64ad_+0x25c>
mov    -0x38(%rbp),%rax
imul   $0x5,(%rax),%eax
mov    %eax,-0x7c(%rbp)
mov    0x20(%rbp),%rax
mov    (%rax),%eax
cmp    -0x7c(%rbp),%eax
jge    1422 <mc64ad_+0x2b2>
mov    0x48(%rbp),%rax
movl   $0xfffffffc,0x4(%rax)
mov    -0x7c(%rbp),%ecx
mov    0x48(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    0x40(%rbp),%rax
cmpl   $0x0,0x4(%rax)
jl     141d <mc64ad_+0x2ad>
mov    0x48(%rbp),%rax
mov    0x4(%rax),%esi
mov    -0x7c(%rbp),%ecx
lea    0x1c02(%rip),%rdi
lea    0x1c5a(%rip),%rdx
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2697 <mc64ad_+0x1527>
mov    -0x30(%rbp),%rax
cmpl   $0x1,(%rax)
jle    14f2 <mc64ad_+0x382>
mov    -0x30(%rbp),%rax
cmpl   $0x2,(%rax)
jne    1445 <mc64ad_+0x2d5>
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x30(%rbp),%rax
cmpl   $0x3,(%rax)
jne    145b <mc64ad_+0x2eb>
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x30(%rbp),%rax
cmpl   $0x4,(%rax)
jne    147a <mc64ad_+0x30a>
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
shl    $0x1,%eax
mov    -0x40(%rbp),%rcx
add    (%rcx),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x30(%rbp),%rax
cmpl   $0x5,(%rax)
jne    1497 <mc64ad_+0x327>
mov    -0x38(%rbp),%rax
imul   $0x3,(%rax),%eax
mov    -0x40(%rbp),%rcx
add    (%rcx),%eax
mov    %eax,-0x7c(%rbp)
mov    0x30(%rbp),%rax
mov    (%rax),%eax
cmp    -0x7c(%rbp),%eax
jge    14ed <mc64ad_+0x37d>
mov    0x48(%rbp),%rax
movl   $0xfffffffb,0x4(%rax)
mov    -0x7c(%rbp),%ecx
mov    0x48(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    0x40(%rbp),%rax
cmpl   $0x0,0x4(%rax)
jl     14e8 <mc64ad_+0x378>
mov    0x48(%rbp),%rax
mov    0x4(%rax),%esi
mov    -0x7c(%rbp),%ecx
lea    0x1b37(%rip),%rdi
lea    0x1bb5(%rip),%rdx
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2697 <mc64ad_+0x1527>
jmp    14f2 <mc64ad_+0x382>
mov    0x40(%rbp),%rax
cmpl   $0x0,0x10(%rax)
jne    169d <mc64ad_+0x52d>
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x1,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     1539 <mc64ad_+0x3c9>
mov    0x28(%rbp),%rax
movslq -0x74(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1510 <mc64ad_+0x3a0>
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     1698 <mc64ad_+0x528>
mov    -0x48(%rbp),%rax
mov    -0x78(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x60(%rbp),%eax
jg     1685 <mc64ad_+0x515>
mov    -0x50(%rbp),%rax
movslq -0x7c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
cmpl   $0x1,-0x74(%rbp)
jl     15ac <mc64ad_+0x43c>
mov    -0x74(%rbp),%eax
mov    -0x38(%rbp),%rcx
cmp    (%rcx),%eax
jle    15fe <mc64ad_+0x48e>
mov    0x48(%rbp),%rax
movl   $0xfffffffa,0x4(%rax)
mov    -0x78(%rbp),%ecx
mov    0x48(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    0x40(%rbp),%rax
cmpl   $0x0,0x4(%rax)
jl     15f9 <mc64ad_+0x489>
mov    0x48(%rbp),%rax
mov    0x4(%rax),%esi
mov    -0x78(%rbp),%ecx
mov    -0x74(%rbp),%r9d
lea    0x1a2d(%rip),%rdi
lea    0x1b07(%rip),%rdx
lea    0x1aca(%rip),%r8
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2697 <mc64ad_+0x1527>
mov    0x28(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x78(%rbp),%eax
jne    1664 <mc64ad_+0x4f4>
mov    0x48(%rbp),%rax
movl   $0xfffffff9,0x4(%rax)
mov    -0x78(%rbp),%ecx
mov    0x48(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    0x40(%rbp),%rax
cmpl   $0x0,0x4(%rax)
jl     165f <mc64ad_+0x4ef>
mov    0x48(%rbp),%rax
mov    0x4(%rax),%esi
mov    -0x78(%rbp),%ecx
mov    -0x74(%rbp),%r9d
lea    0x19c7(%rip),%rdi
lea    0x1a9a(%rip),%rdx
lea    0x1aa6(%rip),%r8
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2697 <mc64ad_+0x1527>
mov    -0x78(%rbp),%edx
mov    0x28(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1677 <mc64ad_+0x507>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1579 <mc64ad_+0x409>
jmp    168a <mc64ad_+0x51a>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1549 <mc64ad_+0x3d9>
jmp    169d <mc64ad_+0x52d>
mov    0x40(%rbp),%rax
cmpl   $0x0,0xc(%rax)
jl     1856 <mc64ad_+0x6e6>
mov    -0x30(%rbp),%rax
mov    (%rax),%esi
mov    -0x38(%rbp),%rax
mov    (%rax),%edx
mov    -0x40(%rbp),%rax
mov    (%rax),%ecx
lea    0x1a6c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1aa3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    -0x38(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1742 <mc64ad_+0x5d2>
mov    -0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0x19f4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x78(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    172f <mc64ad_+0x5bf>
lea    0x1ab6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1734 <mc64ad_+0x5c4>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    16e0 <mc64ad_+0x570>
lea    0x1a3c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    -0x40(%rbp),%rcx
cmp    (%rcx),%eax
jg     17b4 <mc64ad_+0x644>
mov    -0x50(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0x1982(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x78(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    17a1 <mc64ad_+0x631>
lea    0x1a44(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    17a6 <mc64ad_+0x636>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1757 <mc64ad_+0x5e7>
lea    0x1a23(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%rax
cmpl   $0x1,(%rax)
jle    1851 <mc64ad_+0x6e1>
lea    0x19be(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    -0x40(%rbp),%rcx
cmp    (%rcx),%eax
jg     1843 <mc64ad_+0x6d3>
mov    -0x58(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x199d(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x78(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1830 <mc64ad_+0x6c0>
lea    0x19b5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1835 <mc64ad_+0x6c5>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    17e4 <mc64ad_+0x674>
lea    0x1994(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1856 <mc64ad_+0x6e6>
movl   $0x1,-0x74(%rbp)
cmpl   $0xa,-0x74(%rbp)
jg     1884 <mc64ad_+0x714>
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    185d <mc64ad_+0x6ed>
mov    -0x30(%rbp),%rax
cmpl   $0x1,(%rax)
jne    18f4 <mc64ad_+0x784>
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     18e1 <mc64ad_+0x771>
mov    -0x48(%rbp),%rax
mov    -0x78(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
sub    (%rax,%rcx,4),%edx
mov    0x28(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    18a1 <mc64ad_+0x731>
lea    0x18c3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    243b <mc64ad_+0x12cb>
mov    -0x30(%rbp),%rax
cmpl   $0x2,(%rax)
jne    19aa <mc64ad_+0x83a>
mov    -0x38(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x48(%rbp),%rdx
add    $0x4,%rdx
mov    -0x50(%rbp),%rcx
add    $0x4,%rcx
mov    -0x58(%rbp),%r8
add    $0x8,%r8
mov    0x18(%rbp),%r9
add    $0x4,%r9
mov    0x10(%rbp),%r15
mov    0x28(%rbp),%r14
add    $0x4,%r14
mov    0x28(%rbp),%rbx
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%rbx
mov    0x28(%rbp),%r11
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%r11
mov    0x28(%rbp),%r10
mov    -0x38(%rbp),%rax
imul   $0x3,(%rax),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%r10
mov    0x38(%rbp),%rax
add    $0x8,%rax
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1090 <mc64bd_@plt>
jmp    243b <mc64ad_+0x12cb>
mov    -0x30(%rbp),%rax
cmpl   $0x3,(%rax)
jne    1bd6 <mc64ad_+0xa66>
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x1,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     1a66 <mc64ad_+0x8f6>
mov    -0x50(%rbp),%rax
movslq -0x7c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x28(%rbp),%rax
movslq -0x7c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1a1f <mc64ad_+0x8af>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    1a43 <mc64ad_+0x8d3>
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    19c7 <mc64ad_+0x857>
mov    -0x38(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x48(%rbp),%rdx
add    $0x4,%rdx
mov    0x28(%rbp),%rcx
add    $0x4,%rcx
mov    0x38(%rbp),%r8
add    $0x8,%r8
call   1040 <mc64rd_@plt>
mov    -0x38(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x48(%rbp),%rdx
add    $0x4,%rdx
mov    0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0xa0(%rbp)
mov    0x38(%rbp),%r8
add    $0x8,%r8
mov    0x18(%rbp),%r9
add    $0x4,%r9
mov    0x10(%rbp),%r13
mov    0x28(%rbp),%r12
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%r12
mov    0x28(%rbp),%r15
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
mov    -0x38(%rbp),%rcx
add    (%rcx),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%r15
mov    0x28(%rbp),%r14
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
mov    -0x38(%rbp),%rcx
mov    (%rcx),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%r14
mov    0x28(%rbp),%rbx
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
mov    -0x38(%rbp),%rcx
imul   $0x3,(%rcx),%ecx
add    %ecx,%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%rbx
mov    0x28(%rbp),%r11
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
mov    -0x38(%rbp),%rcx
mov    (%rcx),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%r11
mov    0x28(%rbp),%r10
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
mov    -0x38(%rbp),%rcx
imul   $0x5,(%rcx),%ecx
add    %ecx,%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%r10
mov    0x28(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x40(%rbp),%rax
mov    (%rax),%ecx
mov    -0x38(%rbp),%rax
imul   $0x6,(%rax),%eax
add    %eax,%ecx
mov    -0xa8(%rbp),%rax
add    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0xa0(%rbp),%rcx
mov    %r13,(%rsp)
mov    %r12,0x8(%rsp)
mov    %r15,0x10(%rsp)
mov    %r14,0x18(%rsp)
mov    %rbx,0x20(%rsp)
mov    %r11,0x28(%rsp)
mov    %r10,0x30(%rsp)
mov    %rax,0x38(%rsp)
call   1060 <mc64sd_@plt>
jmp    243b <mc64ad_+0x12cb>
mov    -0x30(%rbp),%rax
cmpl   $0x4,(%rax)
jne    1f10 <mc64ad_+0xda0>
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     1e0e <mc64ad_+0xc9e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    -0x78(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x60(%rbp),%eax
jg     1d27 <mc64ad_+0xbb7>
mov    -0x58(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1c70 <mc64ad_+0xb00>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    1c94 <mc64ad_+0xb24>
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
ucomisd -0x88(%rbp),%xmm0
ff
jbe    1d14 <mc64ad_+0xba4>
mov    -0x58(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1ce0 <mc64ad_+0xb70>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    1d04 <mc64ad_+0xb94>
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
jmp    1d19 <mc64ad_+0xba9>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1c2e <mc64ad_+0xabe>
mov    -0x48(%rbp),%rax
mov    -0x78(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x60(%rbp),%eax
jg     1dfb <mc64ad_+0xc8b>
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x58(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1d9d <mc64ad_+0xc2d>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    1dc1 <mc64ad_+0xc51>
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xc8(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
mov    0x38(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rcx),%ecx
shl    $0x1,%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1d4b <mc64ad_+0xbdb>
jmp    1e00 <mc64ad_+0xc90>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1bf3 <mc64ad_+0xa83>
mov    -0x38(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x48(%rbp),%rdx
add    $0x4,%rdx
mov    -0x50(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0xd0(%rbp)
mov    0x38(%rbp),%r8
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
add    %rax,%r8
mov    0x18(%rbp),%r9
add    $0x4,%r9
mov    0x10(%rbp),%r13
mov    0x28(%rbp),%r12
add    $0x4,%r12
mov    0x28(%rbp),%r15
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%r15
mov    0x28(%rbp),%r14
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%r14
mov    0x28(%rbp),%rbx
mov    -0x38(%rbp),%rax
imul   $0x3,(%rax),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%rbx
mov    0x28(%rbp),%r11
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
shl    $0x2,%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%r11
mov    0x38(%rbp),%r10
add    $0x8,%r10
mov    0x38(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0xd0(%rbp),%rcx
mov    %r13,(%rsp)
mov    %r12,0x8(%rsp)
mov    %r15,0x10(%rsp)
mov    %r14,0x18(%rsp)
mov    %rbx,0x20(%rsp)
mov    %r11,0x28(%rsp)
mov    %r10,0x30(%rsp)
mov    %rax,0x38(%rsp)
call   1050 <mc64wd_@plt>
jmp    243b <mc64ad_+0x12cb>
mov    -0x30(%rbp),%rax
cmpl   $0x5,(%rax)
jne    2436 <mc64ad_+0x12c6>
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     21ba <mc64ad_+0x104a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    -0x78(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x60(%rbp),%eax
jg     2041 <mc64ad_+0xed1>
mov    -0x58(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1faa <mc64ad_+0xe3a>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    1fce <mc64ad_+0xe5e>
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   $0x3,(%rcx),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   $0x3,(%rcx),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x88(%rbp),%xmm0
jbe    202e <mc64ad_+0xebe>
mov    0x38(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   $0x3,(%rcx),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    2033 <mc64ad_+0xec3>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1f68 <mc64ad_+0xdf8>
movsd  -0x88(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rcx),%ecx
shl    $0x1,%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2081 <mc64ad_+0xf11>
jp     2081 <mc64ad_+0xf11>
jmp    209b <mc64ad_+0xf2b>
movsd  -0x88(%rbp),%xmm0
ff
call   1080 <log@plt>
movsd  %xmm0,-0x88(%rbp)
ff
jmp    20b7 <mc64ad_+0xf47>
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
cvtsi2sdl (%rax),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    -0x78(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x60(%rbp),%eax
jg     21a7 <mc64ad_+0x1037>
mov    0x38(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   $0x3,(%rcx),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2115 <mc64ad_+0xfa5>
jp     2115 <mc64ad_+0xfa5>
jmp    216a <mc64ad_+0xffa>
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
mov    0x38(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   $0x3,(%rcx),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1080 <log@plt>
movaps %xmm0,%xmm1
movsd  -0xe0(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
mov    0x38(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   $0x3,(%rcx),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2194 <mc64ad_+0x1024>
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
cvtsi2sdl (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    0x38(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   $0x3,(%rcx),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2199 <mc64ad_+0x1029>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    20db <mc64ad_+0xf6b>
jmp    21ac <mc64ad_+0x103c>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1f2d <mc64ad_+0xdbd>
mov    -0x38(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x48(%rbp),%rdx
add    $0x4,%rdx
mov    -0x50(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0xe8(%rbp)
mov    0x38(%rbp),%r8
mov    -0x38(%rbp),%rax
imul   $0x3,(%rax),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
add    %rax,%r8
mov    0x18(%rbp),%r9
add    $0x4,%r9
mov    0x10(%rbp),%r13
mov    0x28(%rbp),%r12
add    $0x4,%r12
mov    0x28(%rbp),%r15
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%r15
mov    0x28(%rbp),%r14
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%r14
mov    0x28(%rbp),%rbx
mov    -0x38(%rbp),%rax
imul   $0x3,(%rax),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%rbx
mov    0x28(%rbp),%r11
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
shl    $0x2,%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%r11
mov    0x38(%rbp),%r10
add    $0x8,%r10
mov    0x38(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0xe8(%rbp),%rcx
mov    %r13,(%rsp)
mov    %r12,0x8(%rsp)
mov    %r15,0x10(%rsp)
mov    %r14,0x18(%rsp)
mov    %rbx,0x20(%rsp)
mov    %r11,0x28(%rsp)
mov    %r10,0x30(%rsp)
mov    %rax,0x38(%rsp)
call   1050 <mc64wd_@plt>
mov    0x10(%rbp),%rax
mov    (%rax),%eax
mov    -0x38(%rbp),%rcx
cmp    (%rcx),%eax
jne    2386 <mc64ad_+0x1216>
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     2381 <mc64ad_+0x1211>
mov    0x38(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rcx),%ecx
shl    $0x1,%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2313 <mc64ad_+0x11a3>
jp     2313 <mc64ad_+0x11a3>
jmp    2356 <mc64ad_+0x11e6>
mov    0x38(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rcx),%ecx
shl    $0x1,%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1080 <log@plt>
movaps %xmm0,%xmm1
mov    0x38(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rcx),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    236e <mc64ad_+0x11fe>
mov    0x38(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rcx),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    2373 <mc64ad_+0x1203>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    22d7 <mc64ad_+0x1167>
jmp    2386 <mc64ad_+0x1216>
movsd  -0x90(%rbp),%xmm0
ff
call   1080 <log@plt>
movsd  0xc65(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     2431 <mc64ad_+0x12c1>
mov    0x38(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    240e <mc64ad_+0x129e>
mov    0x38(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rcx),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    240e <mc64ad_+0x129e>
jmp    241e <mc64ad_+0x12ae>
mov    0x48(%rbp),%rax
movl   $0x2,0x4(%rax)
jmp    243b <mc64ad_+0x12cb>
jmp    2423 <mc64ad_+0x12b3>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    23b7 <mc64ad_+0x1247>
jmp    2436 <mc64ad_+0x12c6>
jmp    243b <mc64ad_+0x12cb>
mov    0x48(%rbp),%rax
cmpl   $0x0,0x4(%rax)
jne    2495 <mc64ad_+0x1325>
mov    0x10(%rbp),%rax
mov    (%rax),%eax
mov    -0x38(%rbp),%rcx
cmp    (%rcx),%eax
jge    2495 <mc64ad_+0x1325>
mov    0x48(%rbp),%rax
movl   $0x1,0x4(%rax)
mov    0x40(%rbp),%rax
cmpl   $0x0,0x8(%rax)
jl     2490 <mc64ad_+0x1320>
mov    0x48(%rbp),%rax
mov    0x4(%rax),%esi
lea    0xd5e(%rip),%rdi
lea    0xd84(%rip),%rdx
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2495 <mc64ad_+0x1325>
mov    0x48(%rbp),%rax
cmpl   $0x2,0x4(%rax)
jne    24d2 <mc64ad_+0x1362>
mov    0x40(%rbp),%rax
cmpl   $0x0,0x8(%rax)
jl     24cd <mc64ad_+0x135d>
mov    0x48(%rbp),%rax
mov    0x4(%rax),%esi
lea    0xd75(%rip),%rdi
lea    0xd9c(%rip),%rdx
mov    $0x0,%al
call   1030 <printf@plt>
jmp    24d2 <mc64ad_+0x1362>
mov    0x40(%rbp),%rax
cmpl   $0x0,0xc(%rax)
jl     2692 <mc64ad_+0x1522>
mov    0x48(%rbp),%rax
mov    0x4(%rax),%esi
mov    0x48(%rbp),%rax
mov    0x8(%rax),%edx
lea    0xd9d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    0x10(%rbp),%rax
mov    (%rax),%esi
lea    0xdc6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xdc7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    -0x38(%rbp),%rcx
cmp    (%rcx),%eax
jg     2582 <mc64ad_+0x1412>
mov    0x18(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xbb4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x78(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    256f <mc64ad_+0x13ff>
lea    0xc76(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2574 <mc64ad_+0x1404>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    2525 <mc64ad_+0x13b5>
mov    -0x30(%rbp),%rax
cmpl   $0x5,(%rax)
jne    268d <mc64ad_+0x151d>
lea    0xd57(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    -0x38(%rbp),%rcx
cmp    (%rcx),%eax
jg     2603 <mc64ad_+0x1493>
mov    0x38(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xd36(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x78(%rbp),%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    25f0 <mc64ad_+0x1480>
lea    0xbf5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    25f5 <mc64ad_+0x1485>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    25a4 <mc64ad_+0x1434>
lea    0xcfa(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    -0x38(%rbp),%rcx
cmp    (%rcx),%eax
jg     267f <mc64ad_+0x150f>
mov    0x38(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rcx),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xcba(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x78(%rbp),%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    266c <mc64ad_+0x14fc>
lea    0xb79(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2671 <mc64ad_+0x1501>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    2618 <mc64ad_+0x14a8>
lea    0xb58(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2692 <mc64ad_+0x1522>
jmp    2697 <mc64ad_+0x1527>
xor    %eax,%eax
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<mc64ad_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9,%r15
mov    %r8,0x8(%rsp)
mov    %rcx,0x10(%rsp)
mov    %rdx,0x20(%rsp)
mov    %rsi,%r14
mov    %rdi,%rbp
mov    0xc8(%rsp),%r13
mov    0xc0(%rsp),%r12
lea    0x1e67(%rip),%rdi
xor    %eax,%eax
call   10a0 <dlamch_@plt>
mov    0x0(%rbp),%edi
lea    -0x6(%rdi),%ecx
cmp    $0xfffffffa,%ecx
ja     1224 <mc64ad_+0x84>
movl   $0xffffffff,0x0(%r13)
ff
mov    0x0(%rbp),%eax
mov    %eax,0x4(%r13)
cmpl   $0x0,(%r12)
js     13a3 <mc64ad_+0x203>
mov    0x0(%rbp),%ecx
lea    0x1e3a(%rip),%rdi
lea    0x1e5c(%rip),%rdx
mov    $0xffffffff,%esi
jmp    139c <mc64ad_+0x1fc>
mov    (%r14),%edx
test   %edx,%edx
jle    128c <mc64ad_+0xec>
mov    0x20(%rsp),%rcx
mov    (%rcx),%r11d
test   %r11d,%r11d
jle    12c1 <mc64ad_+0x121>
mov    %eax,0x28(%rsp)
mov    0xa0(%rsp),%r8
lea    (%rdx,%rdx,4),%ecx
lea    -0x2(%rdi),%eax
cmp    $0x3,%eax
ja     12f5 <mc64ad_+0x155>
mov    $0x1,%r10b
xor    %r9d,%r9d
lea    0x1dbc(%rip),%rbx
movslq (%rbx,%rax,4),%rsi
add    %rbx,%rsi
mov    %ecx,%eax
jmp    *%rsi
lea    0x0(,%rdx,4),%eax
xor    %r9d,%r9d
mov    %edx,%ecx
xor    %r10d,%r10d
cmp    %eax,(%r8)
jge    1315 <mc64ad_+0x175>
jmp    1337 <mc64ad_+0x197>
movl   $0xfffffffe,0x0(%r13)
ff
mov    (%r14),%eax
mov    %eax,0x4(%r13)
cmpl   $0x0,(%r12)
js     13a3 <mc64ad_+0x203>
mov    0x0(%rbp),%ecx
lea    0x1d9d(%rip),%rdi
lea    0x1dd2(%rip),%rdx
mov    $0xfffffffe,%esi
jmp    139c <mc64ad_+0x1fc>
movl   $0xfffffffd,0x0(%r13)
ff
mov    (%rcx),%eax
mov    %eax,0x4(%r13)
cmpl   $0x0,(%r12)
js     13a3 <mc64ad_+0x203>
mov    0x0(%rbp),%ecx
lea    0x1d69(%rip),%rdi
lea    0x1daf(%rip),%rdx
mov    $0xfffffffd,%esi
jmp    139c <mc64ad_+0x1fc>
mov    %ecx,%eax
cmp    %ecx,(%r8)
jl     1337 <mc64ad_+0x197>
jmp    13b4 <mc64ad_+0x214>
lea    (%rdx,%rdx,4),%eax
lea    (%r11,%rax,2),%ecx
mov    $0x1,%r9b
xor    %r10d,%r10d
mov    %ecx,%eax
cmp    %eax,(%r8)
jl     1337 <mc64ad_+0x197>
cmp    $0x2,%edi
jb     13b4 <mc64ad_+0x214>
test   %r9b,%r9b
cmovne %r11d,%ecx
test   %r10b,%r10b
je     136a <mc64ad_+0x1ca>
lea    (%r11,%rdx,2),%ecx
jmp    136a <mc64ad_+0x1ca>
mov    %ecx,%eax
cmp    %ecx,(%r8)
jge    1361 <mc64ad_+0x1c1>
movl   $0xfffffffc,0x0(%r13)
ff
mov    %eax,0x4(%r13)
cmpl   $0x0,(%r12)
js     13a3 <mc64ad_+0x203>
lea    0x1cfc(%rip),%rdi
lea    0x1d54(%rip),%rdx
mov    $0xfffffffc,%esi
mov    %eax,%ecx
jmp    139c <mc64ad_+0x1fc>
lea    (%rdx,%rdx,2),%eax
add    %eax,%r11d
mov    %r11d,%ecx
mov    0xb0(%rsp),%rax
cmp    %ecx,(%rax)
jge    13b4 <mc64ad_+0x214>
movl   $0xfffffffb,0x0(%r13)
ff
mov    %ecx,0x4(%r13)
cmpl   $0x0,(%r12)
js     13a3 <mc64ad_+0x203>
lea    0x1cbd(%rip),%rdi
lea    0x1d3b(%rip),%rdx
mov    $0xfffffffb,%esi
xor    %eax,%eax
call   1050 <printf@plt>
xor    %eax,%eax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0xa8(%rsp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x18(%rsp)
cmpl   $0x0,0xc(%r12)
je     1546 <mc64ad_+0x3a6>
cmpl   $0x0,0x8(%r12)
mov    %r14,(%rsp)
mov    %rbp,0x38(%rsp)
js     15ee <mc64ad_+0x44e>
mov    0x0(%rbp),%esi
mov    (%r14),%edx
mov    0x20(%rsp),%r13
mov    0x0(%r13),%ecx
lea    0x1d70(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x1da7(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
cmpl   $0x0,(%r14)
mov    0x10(%rsp),%r12
js     1463 <mc64ad_+0x2c3>
lea    0x1d13(%rip),%r14
xor    %ebx,%ebx
jmp    1440 <mc64ad_+0x2a0>
nopw   0x0(%rax,%rax,1)
mov    (%rsp),%rax
movslq (%rax),%rax
add    $0x1,%rbx
cmp    %rax,%rbx
jg     1463 <mc64ad_+0x2c3>
lea    0x1(%rbx),%ebp
mov    (%r12,%rbx,4),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
test   $0x7,%bpl
jne    1430 <mc64ad_+0x290>
mov    $0xa,%edi
call   1030 <putchar@plt>
jmp    1430 <mc64ad_+0x290>
lea    0x1d57(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
cmpl   $0x0,0x0(%r13)
mov    0x8(%rsp),%r12
jle    14c0 <mc64ad_+0x320>
lea    0x1cb2(%rip),%r14
xor    %ebx,%ebx
jmp    149d <mc64ad_+0x2fd>
nopl   0x0(%rax,%rax,1)
movslq 0x0(%r13),%rax
add    $0x1,%rbx
cmp    %rax,%rbx
jge    14c0 <mc64ad_+0x320>
lea    0x1(%rbx),%ebp
mov    (%r12,%rbx,4),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
test   $0x7,%bpl
jne    1490 <mc64ad_+0x2f0>
mov    $0xa,%edi
call   1030 <putchar@plt>
jmp    1490 <mc64ad_+0x2f0>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x38(%rsp),%rbp
cmpl   $0x2,0x0(%rbp)
mov    (%rsp),%r14
jl     15ee <mc64ad_+0x44e>
lea    0x1cec(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x20(%rsp),%r12
cmpl   $0x0,(%r12)
jle    15db <mc64ad_+0x43b>
xor    %ebx,%ebx
lea    0x1cdc(%rip),%r14
jmp    1521 <mc64ad_+0x381>
cs nopw 0x0(%rax,%rax,1)
movslq (%r12),%rax
add    $0x1,%rbx
cmp    %rax,%rbx
jge    15db <mc64ad_+0x43b>
lea    0x1(%rbx),%ebp
movsd  (%r15,%rbx,8),%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
test   $0x3,%bpl
jne    1510 <mc64ad_+0x370>
mov    $0xa,%edi
call   1030 <putchar@plt>
jmp    1510 <mc64ad_+0x370>
shl    $0x2,%rdx
mov    0xa8(%rsp),%rdi
xor    %esi,%esi
call   1060 <memset@plt>
mov    (%r14),%r10d
test   %r10d,%r10d
jle    13d1 <mc64ad_+0x231>
add    $0x1,%r10
mov    0x8(%rsp),%rax
lea    -0x4(%rax),%r8
mov    $0x1,%ecx
jmp    1586 <mc64ad_+0x3e6>
add    $0x1,%rcx
cmp    %r10,%rcx
je     13d1 <mc64ad_+0x231>
mov    0x10(%rsp),%rdx
mov    (%rdx,%rcx,4),%esi
movslq -0x4(%rdx,%rcx,4),%rbx
cmp    %esi,%ebx
mov    0x18(%rsp),%rdx
jge    1579 <mc64ad_+0x3d9>
lea    (%r8,%rbx,4),%rdi
sub    %ebx,%esi
xor    %ebx,%ebx
mov    (%rdi,%rbx,4),%r9d
test   %r9d,%r9d
jle    1710 <mc64ad_+0x570>
cmp    (%r14),%r9d
jg     1710 <mc64ad_+0x570>
mov    %rdx,%rax
mov    (%rdx,%r9,4),%edx
cmp    %rdx,%rcx
je     1f0d <mc64ad_+0xd6d>
mov    %ecx,(%rax,%r9,4)
add    $0x1,%rbx
cmp    %ebx,%esi
mov    %rax,%rdx
jne    15a4 <mc64ad_+0x404>
jmp    1579 <mc64ad_+0x3d9>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    (%rsp),%r14
mov    0x38(%rsp),%rbp
mov    0xb8(%rsp),%r12
lea    -0x8(%r12),%r13
xorpd  %xmm0,%xmm0
mov    0xc8(%rsp),%rax
movupd %xmm0,0x10(%rax)
movupd %xmm0,(%rax)
movq   $0x0,0x20(%rax)
mov    0x0(%rbp),%eax
add    $0xffffffff,%eax
cmp    $0x4,%eax
ja     2332 <mc64ad_+0x1192>
lea    0x1a02(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    (%r14),%edx
test   %edx,%edx
mov    0x10(%rsp),%rbx
mov    0xa8(%rsp),%rdi
jle    21f0 <mc64ad_+0x1050>
lea    0x1(%rdx),%r9
mov    $0x1,%ecx
cmp    $0x8,%rdx
jb     2170 <mc64ad_+0xfd0>
lea    (%rbx,%r9,4),%rsi
cmp    %rdi,%rsi
jbe    167c <mc64ad_+0x4dc>
lea    (%rdi,%r9,4),%rsi
add    $0xfffffffffffffffc,%rsi
cmp    %rbx,%rsi
ja     2170 <mc64ad_+0xfd0>
mov    %edx,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     2120 <mc64ad_+0xf80>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
mov    0xa8(%rsp),%rbp
movdqu (%rbx,%rsi,4),%xmm0
movdqu 0x4(%rbx,%rsi,4),%xmm1
psubd  %xmm0,%xmm1
movdqu 0x10(%rbx,%rsi,4),%xmm0
movdqu 0x14(%rbx,%rsi,4),%xmm2
psubd  %xmm0,%xmm2
movdqu %xmm1,0x0(%rbp,%rsi,4)
movdqu %xmm2,0x10(%rbp,%rsi,4)
movdqu 0x20(%rbx,%rsi,4),%xmm0
movdqu 0x24(%rbx,%rsi,4),%xmm1
psubd  %xmm0,%xmm1
movdqu 0x30(%rbx,%rsi,4),%xmm0
movdqu 0x34(%rbx,%rsi,4),%xmm2
psubd  %xmm0,%xmm2
movdqu %xmm1,0x20(%rbp,%rsi,4)
movdqu %xmm2,0x30(%rbp,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    16aa <mc64ad_+0x50a>
jmp    2122 <mc64ad_+0xf82>
movl   $0xfffffffa,0x0(%r13)
ff
mov    %ecx,0x4(%r13)
cmpl   $0x0,(%r12)
js     13a3 <mc64ad_+0x203>
lea    0x191f(%rip),%rdi
lea    0x19f9(%rip),%rdx
lea    0x19bc(%rip),%r8
mov    $0xfffffffa,%esi
jmp    1f3e <mc64ad_+0xd9e>
movslq (%r14),%rax
mov    0x18(%rsp),%rdx
lea    (%rdx,%rax,4),%rbp
add    $0x4,%rbp
lea    0x1(%rax,%rax,1),%ecx
movslq %ecx,%rcx
lea    (%rdx,%rcx,4),%rbx
lea    (%rax,%rax,2),%rax
lea    0x4(%rdx,%rax,4),%rax
mov    (%rsp),%rdi
mov    0x20(%rsp),%rsi
mov    0x10(%rsp),%rdx
mov    0x8(%rsp),%rcx
mov    %r15,%r8
mov    0x98(%rsp),%r9
push   %r12
push   %rax
push   %rbx
push   %rbp
mov    0x20(%rsp),%r14
push   0xc8(%rsp)
push   0xb8(%rsp)
call   10c0 <mc64bd_@plt>
add    $0x30,%rsp
jmp    2332 <mc64ad_+0x1192>
mov    0x20(%rsp),%rax
mov    (%rax),%ecx
test   %ecx,%ecx
mov    0xa8(%rsp),%rbp
jle    225c <mc64ad_+0x10bc>
lea    0x1(%rcx),%rax
mov    $0x1,%edx
cmp    $0x2,%rcx
jae    1fe9 <mc64ad_+0xe49>
mov    %rdx,%rcx
not    %rcx
test   $0x1,%al
jne    1826 <mc64ad_+0x686>
mov    0x8(%rsp),%rsi
mov    -0x4(%rsi,%rdx,4),%esi
mov    0x18(%rsp),%rdi
mov    %esi,(%rdi,%rdx,4)
movsd  -0x8(%r15,%rdx,8),%xmm0
movapd 0x17fe(%rip),%xmm1
xorpd  %xmm0,%xmm1
xorpd  %xmm2,%xmm2
cmplesd %xmm0,%xmm2
andpd  %xmm2,%xmm0
andnpd %xmm1,%xmm2
orpd   %xmm0,%xmm2
movlpd %xmm2,0x0(%r13,%rdx,8)
add    $0x1,%rdx
add    %rax,%rcx
mov    0x8(%rsp),%rsi
je     225c <mc64ad_+0x10bc>
movapd 0x17c4(%rip),%xmm0
mov    -0x4(%rsi,%rdx,4),%ecx
mov    %ecx,-0x4(%rbp,%rdx,4)
movsd  -0x8(%r15,%rdx,8),%xmm1
movapd %xmm1,%xmm2
xorpd  %xmm0,%xmm2
xorpd  %xmm3,%xmm3
cmplesd %xmm1,%xmm3
andpd  %xmm3,%xmm1
andnpd %xmm2,%xmm3
orpd   %xmm1,%xmm3
movlpd %xmm3,-0x8(%r12,%rdx,8)
mov    (%rsi,%rdx,4),%ecx
mov    %ecx,0x0(%rbp,%rdx,4)
movsd  (%r15,%rdx,8),%xmm1
movapd %xmm1,%xmm2
xorpd  %xmm0,%xmm2
xorpd  %xmm3,%xmm3
cmplesd %xmm1,%xmm3
andpd  %xmm3,%xmm1
andnpd %xmm2,%xmm3
orpd   %xmm1,%xmm3
movlpd %xmm3,(%r12,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rax
jne    183c <mc64ad_+0x69c>
jmp    225c <mc64ad_+0x10bc>
movslq (%r14),%rdi
lea    (%rdi,%rdi,1),%eax
mov    %edi,%r12d
test   %rdi,%rdi
jle    1f65 <mc64ad_+0xdc5>
mov    %rdi,0x50(%rsp)
mov    %eax,0x4c(%rsp)
movslq %eax,%rbp
add    $0x1,%r12
mov    0x10(%rsp),%rax
mov    (%rax),%r9d
lea    -0x8(%r15),%rax
mov    %rax,0x28(%rsp)
lea    0x8(%r15),%rax
mov    %rax,0x30(%rsp)
mov    0xb8(%rsp),%rax
lea    0x8(%rax),%rcx
mov    %rcx,0x40(%rsp)
lea    (%rax,%rbp,8),%rdx
mov    $0x1,%r14d
movapd 0x16f3(%rip),%xmm10
xorpd  %xmm8,%xmm8
movapd 0x16e5(%rip),%xmm9
jmp    1926 <mc64ad_+0x786>
cmp    %r12,%r14
je     1dc3 <mc64ad_+0xc23>
mov    %r9d,%ebx
mov    0x10(%rsp),%rax
mov    (%rax,%r14,4),%r9d
add    $0x1,%r14
cmp    %r9d,%ebx
jge    191d <mc64ad_+0x77d>
movslq %ebx,%r8
mov    %r9d,%eax
sub    %ebx,%eax
xorpd  %xmm3,%xmm3
mov    %r8,%rsi
test   $0x1,%al
je     197c <mc64ad_+0x7dc>
movsd  -0x8(%r15,%r8,8),%xmm4
movapd %xmm4,%xmm5
xorpd  %xmm9,%xmm5
xorpd  %xmm3,%xmm3
cmplesd %xmm4,%xmm3
andpd  %xmm3,%xmm4
andnpd %xmm5,%xmm3
orpd   %xmm4,%xmm3
maxsd  %xmm8,%xmm3
lea    0x1(%r8),%rsi
movslq %r9d,%rax
mov    %r8,%rcx
not    %rcx
add    %rax,%rcx
je     19ea <mc64ad_+0x84a>
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%r15,%rsi,8),%xmm0
movsd  (%r15,%rsi,8),%xmm1
movapd %xmm0,%xmm2
xorpd  %xmm10,%xmm2
xorpd  %xmm4,%xmm4
cmplesd %xmm0,%xmm4
andpd  %xmm4,%xmm0
andnpd %xmm2,%xmm4
orpd   %xmm0,%xmm4
maxsd  %xmm3,%xmm4
movapd %xmm1,%xmm0
xorpd  %xmm10,%xmm0
xorpd  %xmm3,%xmm3
cmplesd %xmm1,%xmm3
andpd  %xmm3,%xmm1
andnpd %xmm0,%xmm3
orpd   %xmm1,%xmm3
maxsd  %xmm4,%xmm3
add    $0x2,%rsi
cmp    %rsi,%rax
jne    1990 <mc64ad_+0x7f0>
cmp    %r9d,%ebx
jge    191d <mc64ad_+0x77d>
mov    %rax,%r10
sub    %r8,%r10
cmp    $0x4,%r10
jb     1a3c <mc64ad_+0x89c>
lea    (%r8,%rbp,1),%rdi
lea    0x0(,%rdi,8),%rcx
add    %r13,%rcx
mov    0x28(%rsp),%rbx
lea    (%rbx,%rax,8),%rsi
cmp    %rsi,%rcx
jae    1b12 <mc64ad_+0x972>
lea    (%rax,%rbp,1),%rcx
lea    0x0(,%rcx,8),%rcx
add    %r13,%rcx
lea    (%rbx,%r8,8),%rsi
cmp    %rcx,%rsi
jae    1b12 <mc64ad_+0x972>
mov    %r8,%r11
mov    %r9d,%ecx
sub    %r11d,%ecx
mov    %r11,%rsi
test   $0x1,%cl
je     1a89 <mc64ad_+0x8e9>
movsd  -0x8(%r15,%r11,8),%xmm0
movapd %xmm0,%xmm1
xorpd  %xmm9,%xmm1
xorpd  %xmm2,%xmm2
cmplesd %xmm0,%xmm2
andpd  %xmm2,%xmm0
andnpd %xmm1,%xmm2
orpd   %xmm0,%xmm2
movapd %xmm3,%xmm0
subsd  %xmm2,%xmm0
lea    (%r11,%rbp,1),%rcx
movsd  %xmm0,0x0(%r13,%rcx,8)
lea    0x1(%r11),%rsi
not    %r11
add    %rax,%r11
je     191d <mc64ad_+0x77d>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%r15,%rsi,8),%xmm0
movapd %xmm0,%xmm1
xorpd  %xmm10,%xmm1
xorpd  %xmm2,%xmm2
cmplesd %xmm0,%xmm2
andpd  %xmm2,%xmm0
andnpd %xmm1,%xmm2
orpd   %xmm0,%xmm2
movapd %xmm3,%xmm0
subsd  %xmm2,%xmm0
movsd  %xmm0,-0x8(%rdx,%rsi,8)
movsd  (%r15,%rsi,8),%xmm0
movapd %xmm0,%xmm1
xorpd  %xmm10,%xmm1
xorpd  %xmm2,%xmm2
cmplesd %xmm0,%xmm2
andpd  %xmm2,%xmm0
andnpd %xmm1,%xmm2
orpd   %xmm0,%xmm2
movapd %xmm3,%xmm0
subsd  %xmm2,%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rax
jne    1aa0 <mc64ad_+0x900>
jmp    191d <mc64ad_+0x77d>
mov    %r10,%rsi
and    $0xfffffffffffffffc,%rsi
lea    (%rsi,%r8,1),%r11
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
mov    0x30(%rsp),%rcx
lea    (%rcx,%r8,8),%rcx
mov    0x40(%rsp),%rbx
lea    (%rbx,%rdi,8),%rdi
xor    %ebx,%ebx
nopl   0x0(%rax)
movupd -0x10(%rcx,%rbx,8),%xmm5
movupd (%rcx,%rbx,8),%xmm6
xorpd  %xmm7,%xmm7
cmplepd %xmm5,%xmm7
xorpd  %xmm1,%xmm1
cmplepd %xmm6,%xmm1
movapd %xmm5,%xmm2
xorpd  %xmm9,%xmm2
movapd %xmm6,%xmm0
xorpd  %xmm9,%xmm0
andpd  %xmm7,%xmm5
andnpd %xmm2,%xmm7
orpd   %xmm5,%xmm7
andpd  %xmm1,%xmm6
andnpd %xmm0,%xmm1
orpd   %xmm6,%xmm1
movapd %xmm4,%xmm0
subpd  %xmm7,%xmm0
movapd %xmm4,%xmm2
subpd  %xmm1,%xmm2
movupd %xmm0,-0x10(%rdi,%rbx,8)
movupd %xmm2,(%rdi,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%rsi
jne    1b40 <mc64ad_+0x9a0>
cmp    %rsi,%r10
je     191d <mc64ad_+0x77d>
jmp    1a3f <mc64ad_+0x89f>
xorps  %xmm0,%xmm0
cvtsi2sdl 0x28(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
mov    (%r14),%edi
test   %edi,%edi
jle    1dd4 <mc64ad_+0xc34>
add    $0x1,%rdi
mov    $0x1,%ebp
movapd 0x141c(%rip),%xmm4
mov    %rdi,0x40(%rsp)
jmp    1c01 <mc64ad_+0xa61>
mov    0x40(%rsp),%rdi
cmp    %rdi,%rbp
mov    0xb8(%rsp),%r12
je     1dd1 <mc64ad_+0xc31>
mov    0x10(%rsp),%rcx
mov    -0x4(%rcx,%rbp,4),%eax
mov    (%rcx,%rbp,4),%ecx
movslq (%r14),%rdx
cmp    %ecx,%eax
jge    1d1e <mc64ad_+0xb7e>
movslq %eax,%rbx
lea    (%rdx,%rdx,2),%r8
mov    %ecx,%edi
sub    %eax,%edi
xorpd  %xmm0,%xmm0
mov    %rbx,%rsi
test   $0x1,%dil
je     1c6f <mc64ad_+0xacf>
movsd  -0x8(%r15,%rbx,8),%xmm1
movapd %xmm1,%xmm2
xorpd  0x13bd(%rip),%xmm2
xorpd  %xmm0,%xmm0
cmplesd %xmm1,%xmm0
andpd  %xmm0,%xmm1
andnpd %xmm2,%xmm0
orpd   %xmm1,%xmm0
lea    (%rbx,%r8,1),%rsi
movlpd %xmm0,0x0(%r13,%rsi,8)
maxsd  0x13ad(%rip),%xmm0
lea    0x1(%rbx),%rsi
movslq %ecx,%rdi
not    %rbx
add    %rdi,%rbx
je     1ce3 <mc64ad_+0xb43>
lea    (%r12,%r8,8),%rbx
xchg   %ax,%ax
movsd  -0x8(%r15,%rsi,8),%xmm1
movapd %xmm1,%xmm2
xorpd  %xmm4,%xmm2
xorpd  %xmm3,%xmm3
cmplesd %xmm1,%xmm3
andpd  %xmm3,%xmm1
andnpd %xmm2,%xmm3
orpd   %xmm1,%xmm3
movlpd %xmm3,-0x8(%rbx,%rsi,8)
maxsd  %xmm0,%xmm3
movsd  (%r15,%rsi,8),%xmm1
movapd %xmm1,%xmm2
xorpd  %xmm4,%xmm2
xorpd  %xmm0,%xmm0
cmplesd %xmm1,%xmm0
andpd  %xmm0,%xmm1
andnpd %xmm2,%xmm0
orpd   %xmm1,%xmm0
movlpd %xmm0,(%rbx,%rsi,8)
maxsd  %xmm3,%xmm0
add    $0x2,%rsi
cmp    %rsi,%rdi
jne    1c80 <mc64ad_+0xae0>
lea    0x0(%rbp,%rdx,2),%esi
movslq %esi,%rsi
movsd  %xmm0,0x0(%r13,%rsi,8)
ucomisd 0x131f(%rip),%xmm0
jne    1cfd <mc64ad_+0xb5d>
jnp    1d2e <mc64ad_+0xb8e>
call   10b0 <log@plt>
movapd 0x12f6(%rip),%xmm4
movsd  %xmm0,0x28(%rsp)
mov    0x10(%rsp),%rcx
mov    -0x4(%rcx,%rbp,4),%eax
mov    (%rcx,%rbp,4),%ecx
jmp    1d45 <mc64ad_+0xba5>
lea    0x0(%rbp,%rdx,2),%esi
movslq %esi,%rsi
movq   $0x0,0x0(%r13,%rsi,8)
xorps  %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
movsd  0x30(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x28(%rsp)
add    $0x1,%rbp
cmp    %ecx,%eax
jge    1beb <mc64ad_+0xa4b>
mov    (%r14),%edx
mov    %ecx,%ebx
movslq %eax,%r12
jmp    1d85 <mc64ad_+0xbe5>
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
movsd  0x30(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
add    $0x1,%r12
cmp    %r12d,%ebx
je     1beb <mc64ad_+0xa4b>
lea    (%rdx,%rdx,2),%eax
cltq
add    %r12,%rax
movsd  0x0(%r13,%rax,8),%xmm0
ucomisd 0x127c(%rip),%xmm0
jne    1da0 <mc64ad_+0xc00>
jnp    1d60 <mc64ad_+0xbc0>
call   10b0 <log@plt>
movapd 0x1253(%rip),%xmm4
movsd  0x28(%rsp),%xmm1
subsd  %xmm0,%xmm1
movslq (%r14),%rdx
lea    (%rdx,%rdx,2),%rax
add    %r12,%rax
jmp    1d71 <mc64ad_+0xbd1>
mov    0x4c(%rsp),%eax
mov    0x50(%rsp),%rdi
jmp    1f69 <mc64ad_+0xdc9>
mov    (%r14),%edi
lea    (%rdi,%rdi,2),%eax
cltq
lea    0x8(,%rax,8),%r8
add    %r13,%r8
movslq %edi,%rcx
mov    0x18(%rsp),%rsi
lea    0x4(%rsi,%rcx,4),%r10
lea    0x1(%rdi,%rdi,1),%edx
movslq %edx,%rdx
lea    (%rsi,%rdx,4),%r11
lea    0x4(%rsi,%rax,4),%rax
lea    0x1(,%rdi,4),%edx
movslq %edx,%rdx
lea    (%rsi,%rdx,4),%rbp
lea    0x8(%r13,%rcx,8),%rbx
mov    %r14,%rdi
mov    0x20(%rsp),%rsi
mov    0x10(%rsp),%rdx
mov    0x8(%rsp),%rcx
mov    0x98(%rsp),%r9
push   %rbx
push   %r12
push   %rbp
push   %rax
push   %r11
push   %r10
push   0xd8(%rsp)
mov    0xc8(%rsp),%rbx
push   %rbx
call   1080 <mc64wd_@plt>
add    $0x40,%rsp
mov    (%rbx),%eax
mov    (%r14),%ecx
cmp    %ecx,%eax
jne    1ec8 <mc64ad_+0xd28>
test   %ecx,%ecx
jle    1ec8 <mc64ad_+0xd28>
mov    %eax,%ebx
neg    %ebx
mov    $0x1,%ebp
jmp    1e89 <mc64ad_+0xce9>
lea    (%rax,%rbp,1),%ecx
movslq %ecx,%rcx
movq   $0x0,0x0(%r13,%rcx,8)
lea    (%rbx,%rbp,1),%ecx
add    $0x1,%ecx
mov    %ebp,%edx
add    $0x1,%edx
mov    %edx,%ebp
cmp    $0x1,%ecx
je     1ec8 <mc64ad_+0xd28>
lea    0x0(%rbp,%rax,2),%ecx
movslq %ecx,%rcx
movsd  0x0(%r13,%rcx,8),%xmm0
ucomisd 0x1179(%rip),%xmm0
jne    1ea3 <mc64ad_+0xd03>
jnp    1e68 <mc64ad_+0xcc8>
call   10b0 <log@plt>
mov    (%rsp),%rax
mov    (%rax),%eax
lea    (%rax,%rbp,1),%ecx
movslq %ecx,%rcx
movsd  0x0(%r13,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rcx,8)
jmp    1e77 <mc64ad_+0xcd7>
movsd  0x30(%rsp),%xmm0
call   10b0 <log@plt>
mov    (%rsp),%r14
mov    (%r14),%eax
test   %eax,%eax
jle    2332 <mc64ad_+0x1192>
mulsd  0x1126(%rip),%xmm0
lea    (%r12,%rax,8),%rcx
xor    %edx,%edx
ucomisd (%r12,%rdx,8),%xmm0
jbe    1f4a <mc64ad_+0xdaa>
ucomisd (%rcx,%rdx,8),%xmm0
jbe    1f4a <mc64ad_+0xdaa>
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1ef0 <mc64ad_+0xd50>
jmp    2332 <mc64ad_+0x1192>
movl   $0xfffffff9,0x0(%r13)
ff
mov    %ecx,0x4(%r13)
cmpl   $0x0,(%r12)
js     13a3 <mc64ad_+0x203>
lea    0x1122(%rip),%rdi
lea    0x11f5(%rip),%rdx
lea    0x1201(%rip),%r8
mov    $0xfffffff9,%esi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    13a3 <mc64ad_+0x203>
mov    0xc8(%rsp),%rax
movl   $0x2,(%rax)
mov    0x98(%rsp),%r15
jmp    234d <mc64ad_+0x11ad>
add    $0x1,%r12d
or     $0x1,%eax
cltq
lea    0x0(,%rax,8),%r8
add    %r13,%r8
movslq %r12d,%rcx
mov    0x18(%rsp),%rsi
lea    (%rsi,%rcx,4),%r10
lea    (%rsi,%rax,4),%r11
lea    (%rdi,%rdi,2),%rdx
lea    0x4(%rsi,%rdx,4),%rbx
lea    0x1(,%rdi,4),%edx
movslq %edx,%rdx
lea    (%rsi,%rdx,4),%rbp
lea    0x0(%r13,%rcx,8),%rax
mov    (%rsp),%r14
mov    %r14,%rdi
mov    0x20(%rsp),%rsi
mov    0x10(%rsp),%rdx
mov    0x8(%rsp),%rcx
mov    0x98(%rsp),%r9
push   %rax
push   0xc0(%rsp)
push   %rbp
push   %rbx
push   %r11
push   %r10
push   0xd8(%rsp)
push   0xc8(%rsp)
call   1080 <mc64wd_@plt>
jmp    232e <mc64ad_+0x118e>
lea    -0x4(,%rax,4),%rsi
ff
add    %rbp,%rsi
mov    0x8(%rsp),%rbx
lea    (%rbx,%rax,4),%rdi
add    $0xfffffffffffffffc,%rdi
cmp    %rbp,%rdi
seta   %dil
lea    (%r12,%rax,8),%rbp
add    $0xfffffffffffffff8,%rbp
cmp    %rbx,%rsi
seta   %r8b
lea    (%r15,%rax,8),%rsi
add    $0xfffffffffffffff8,%rsi
cmp    %r12,%rsi
seta   %bl
cmp    %r15,%rbp
seta   %sil
test   %r8b,%dil
jne    210f <mc64ad_+0xf6f>
and    %sil,%bl
mov    (%rsp),%r14
mov    0xa8(%rsp),%rbp
jne    17d8 <mc64ad_+0x638>
mov    %ecx,%r8d
and    $0xfffffffe,%r8d
lea    -0x2(%r8),%rsi
mov    %rsi,%r9
shr    %r9
add    $0x1,%r9
test   %rsi,%rsi
je     2201 <mc64ad_+0x1061>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
movapd 0xf87(%rip),%xmm0
mov    0x8(%rsp),%rbx
mov    (%rbx,%rsi,4),%rbp
mov    0xa8(%rsp),%rdx
mov    %rbp,(%rdx,%rsi,4)
movupd (%r15,%rsi,8),%xmm1
xorpd  %xmm2,%xmm2
cmplepd %xmm1,%xmm2
movapd %xmm1,%xmm3
xorpd  %xmm0,%xmm3
andpd  %xmm2,%xmm1
andnpd %xmm3,%xmm2
orpd   %xmm1,%xmm2
movupd %xmm2,(%r12,%rsi,8)
mov    0x8(%rbx,%rsi,4),%rbp
mov    0xa8(%rsp),%rdx
mov    %rbp,0x8(%rdx,%rsi,4)
mov    0xa8(%rsp),%rbp
movupd 0x10(%r15,%rsi,8),%xmm1
xorpd  %xmm2,%xmm2
cmplepd %xmm1,%xmm2
movapd %xmm1,%xmm3
xorpd  %xmm0,%xmm3
andpd  %xmm2,%xmm1
andnpd %xmm3,%xmm2
orpd   %xmm1,%xmm2
movupd %xmm2,0x10(%r12,%rsi,8)
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rdi
jne    207e <mc64ad_+0xede>
jmp    2203 <mc64ad_+0x1063>
mov    (%rsp),%r14
mov    0xa8(%rsp),%rbp
jmp    17d8 <mc64ad_+0x638>
xor    %esi,%esi
test   $0x1,%r8b
je     215f <mc64ad_+0xfbf>
shl    $0x2,%rsi
or     $0x4,%rsi
movdqu -0x4(%rbx,%rsi,1),%xmm0
movdqu (%rbx,%rsi,1),%xmm1
psubd  %xmm0,%xmm1
movdqu 0xc(%rbx,%rsi,1),%xmm0
movdqu 0x10(%rbx,%rsi,1),%xmm2
psubd  %xmm0,%xmm2
mov    0x18(%rsp),%rax
movdqu %xmm1,(%rax,%rsi,1)
movdqu %xmm2,0x10(%rax,%rsi,1)
cmp    %rcx,%rdx
mov    (%rsp),%r14
je     21f0 <mc64ad_+0x1050>
or     $0x1,%rcx
mov    %r9d,%edi
sub    %ecx,%edi
mov    %rcx,%rsi
not    %rsi
add    %r9,%rsi
and    $0x3,%rdi
je     21a2 <mc64ad_+0x1002>
mov    0x18(%rsp),%rax
lea    0x1(%rcx),%rdx
mov    (%rbx,%rcx,4),%ebp
sub    -0x4(%rbx,%rcx,4),%ebp
mov    %ebp,(%rax,%rcx,4)
mov    %rdx,%rcx
add    $0xffffffffffffffff,%rdi
jne    2189 <mc64ad_+0xfe9>
jmp    21a5 <mc64ad_+0x1005>
mov    %rcx,%rdx
cmp    $0x3,%rsi
mov    (%rsp),%r14
mov    0xa8(%rsp),%rsi
jb     21f0 <mc64ad_+0x1050>
mov    (%rbx,%rdx,4),%ecx
sub    -0x4(%rbx,%rdx,4),%ecx
mov    %ecx,-0x4(%rsi,%rdx,4)
mov    0x4(%rbx,%rdx,4),%ecx
sub    (%rbx,%rdx,4),%ecx
mov    %ecx,(%rsi,%rdx,4)
mov    0x8(%rbx,%rdx,4),%ecx
sub    0x4(%rbx,%rdx,4),%ecx
mov    %ecx,0x4(%rsi,%rdx,4)
mov    0xc(%rbx,%rdx,4),%ecx
sub    0x8(%rbx,%rdx,4),%ecx
mov    %ecx,0x8(%rsi,%rdx,4)
lea    0x4(%rdx),%rcx
mov    %rcx,%rdx
cmp    %rcx,%r9
jne    21b7 <mc64ad_+0x1017>
lea    0x1124(%rip),%rdi
call   1040 <puts@plt>
jmp    2332 <mc64ad_+0x1192>
xor    %esi,%esi
test   $0x1,%r9b
je     224f <mc64ad_+0x10af>
or     $0x1,%rsi
mov    0x8(%rsp),%rdx
mov    -0x4(%rdx,%rsi,4),%rdi
mov    0x18(%rsp),%rdx
mov    %rdi,(%rdx,%rsi,4)
movupd -0x8(%r15,%rsi,8),%xmm0
xorpd  %xmm1,%xmm1
cmplepd %xmm0,%xmm1
movapd 0xdc8(%rip),%xmm2
xorpd  %xmm0,%xmm2
andpd  %xmm1,%xmm0
andnpd %xmm2,%xmm1
orpd   %xmm0,%xmm1
movupd %xmm1,0x0(%r13,%rsi,8)
cmp    %r8,%rcx
mov    (%rsp),%r14
jne    257b <mc64ad_+0x13db>
mov    %r14,%rdi
mov    0x20(%rsp),%r15
mov    %r15,%rsi
mov    0x10(%rsp),%rdx
mov    %rbp,%rcx
mov    %r12,%r8
mov    %rbp,%r12
call   1070 <mc64rd_@plt>
mov    (%r15),%ebx
lea    0x1(%rbx),%eax
cltq
mov    0x18(%rsp),%rbp
lea    0x0(%rbp,%rax,4),%rax
mov    %rax,0x28(%rsp)
mov    (%r14),%edx
lea    0x1(%rbx,%rdx,1),%esi
movslq %esi,%rsi
lea    0x0(%rbp,%rsi,4),%rax
mov    %rax,0x30(%rsp)
lea    0x1(%rbx,%rdx,2),%esi
movslq %esi,%rsi
lea    0x0(%rbp,%rsi,4),%rax
mov    %rax,0x8(%rsp)
lea    (%rdx,%rdx,2),%esi
lea    0x1(%rbx,%rsi,1),%edi
movslq %edi,%rdi
lea    0x0(%rbp,%rdi,4),%r11
lea    0x1(%rbx,%rdx,4),%edi
movslq %edi,%rdi
lea    0x0(%rbp,%rdi,4),%r14
lea    (%rdx,%rdx,4),%edx
lea    0x1(%rbx,%rdx,1),%edx
movslq %edx,%rdx
lea    0x0(%rbp,%rdx,4),%r10
lea    0x1(%rbx,%rsi,2),%eax
cltq
lea    0x0(%rbp,%rax,4),%rax
mov    (%rsp),%rdi
mov    %r15,%rsi
mov    0x10(%rsp),%rdx
mov    %r12,%rcx
mov    0xb8(%rsp),%r8
mov    0x98(%rsp),%r9
push   %rax
push   %r10
push   %r14
mov    0x18(%rsp),%r14
push   %r11
push   0x28(%rsp)
push   0x58(%rsp)
push   0x58(%rsp)
push   0xc8(%rsp)
call   1090 <mc64sd_@plt>
add    $0x40,%rsp
mov    0xc8(%rsp),%rax
mov    (%rax),%eax
test   %eax,%eax
mov    0x98(%rsp),%r15
je     2377 <mc64ad_+0x11d7>
cmp    $0x2,%eax
jne    23cb <mc64ad_+0x122b>
mov    0xc0(%rsp),%rax
cmpl   $0x0,0x4(%rax)
js     23cb <mc64ad_+0x122b>
lea    0xed9(%rip),%rdi
lea    0xf00(%rip),%rdx
mov    $0x2,%esi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    23cb <mc64ad_+0x122b>
mov    0x90(%rsp),%rax
mov    (%rax),%eax
cmp    (%r14),%eax
jge    23cb <mc64ad_+0x122b>
mov    0xc8(%rsp),%rax
movl   $0x1,(%rax)
mov    0xc0(%rsp),%rax
cmpl   $0x0,0x4(%rax)
js     23cb <mc64ad_+0x122b>
lea    0xe3e(%rip),%rdi
lea    0xe64(%rip),%rdx
mov    $0x1,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xc8(%rsp),%rax
mov    (%rax),%eax
cmp    $0x2,%eax
je     234d <mc64ad_+0x11ad>
mov    0xc0(%rsp),%rax
cmpl   $0x0,0x8(%rax)
js     13a3 <mc64ad_+0x203>
mov    0xc8(%rsp),%rax
mov    (%rax),%esi
mov    0x4(%rax),%edx
lea    0xea8(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x90(%rsp),%rax
mov    (%rax),%esi
lea    0xecd(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xece(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
cmpl   $0x0,(%r14)
jle    2462 <mc64ad_+0x12c2>
lea    0xd0b(%rip),%r14
xor    %ebp,%ebp
jmp    2440 <mc64ad_+0x12a0>
nop
mov    (%rsp),%rax
movslq (%rax),%rax
add    $0x1,%rbp
cmp    %rax,%rbp
jge    2462 <mc64ad_+0x12c2>
lea    0x1(%rbp),%ebx
mov    (%r15,%rbp,4),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
test   $0x7,%bl
jne    2430 <mc64ad_+0x1290>
mov    $0xa,%edi
call   1030 <putchar@plt>
jmp    2430 <mc64ad_+0x1290>
mov    0x38(%rsp),%rax
cmpl   $0x5,(%rax)
mov    (%rsp),%rbx
jne    13a3 <mc64ad_+0x203>
lea    0xe79(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
cmpl   $0x0,(%rbx)
jle    24ed <mc64ad_+0x134d>
mov    $0x1,%ebx
xor    %ebp,%ebp
mov    $0xcccccccd,%r12d
lea    0xe69(%rip),%r14
jmp    24b3 <mc64ad_+0x1313>
nopl   (%rax)
mov    (%rsp),%rax
movslq (%rax),%rax
add    $0x1,%rbp
add    $0x1,%ebx
cmp    %rax,%rbp
jge    24ed <mc64ad_+0x134d>
mov    %ebx,%eax
imul   %r12,%rax
shr    $0x22,%rax
lea    (%rax,%rax,4),%r15d
add    $0xffffffff,%r15d
mov    0xb8(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
cmp    %ebp,%r15d
jne    24a0 <mc64ad_+0x1300>
mov    $0xa,%edi
call   1030 <putchar@plt>
jmp    24a0 <mc64ad_+0x1300>
lea    0xe17(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    (%rsp),%rax
mov    (%rax),%ecx
test   %ecx,%ecx
jle    256c <mc64ad_+0x13cc>
mov    $0x1,%ebp
xor    %ebx,%ebx
movabs $0xcccccccccccccccd,%r12
cc cc cc
lea    0xde7(%rip),%r14
jmp    2532 <mc64ad_+0x1392>
nop
mov    (%rsp),%rax
mov    (%rax),%ecx
add    $0x1,%rbx
add    $0x1,%rbp
cmp    %ecx,%ebx
jge    256c <mc64ad_+0x13cc>
mov    %rbp,%rax
mul    %r12
shr    $0x2,%rdx
lea    (%rdx,%rdx,4),%r15d
add    $0xffffffff,%r15d
movslq %ecx,%rax
add    %rbx,%rax
movsd  0x8(%r13,%rax,8),%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
cmp    %ebx,%r15d
jne    2520 <mc64ad_+0x1380>
mov    $0xa,%edi
call   1030 <putchar@plt>
jmp    2520 <mc64ad_+0x1380>
mov    $0xa,%edi
call   1030 <putchar@plt>
jmp    13a3 <mc64ad_+0x203>
or     $0x1,%rcx
mov    %rcx,%rdx
jmp    17d8 <mc64ad_+0x638>

LLVM IR (-O0):
@.str = [9 x i8] c"Overflow\00"
@.str.1 = [41 x i8] c" ****** Error in MC64A/AD. INFO(1) = %2d\00"
@.str.2 = [19 x i8] c" because JOB = %d\0A\00"
@.str.3 = [17 x i8] c" because N = %d\0A\00"
@.str.4 = [18 x i8] c" because NE = %d\0A\00"
@.str.5 = [38 x i8] c" LIW too small, must be at least %8d\0A\00"
@.str.6 = [38 x i8] c" LDW too small, must be at least %8d\0A\00"
@.str.7 = [12 x i8] c" Column %8d\00"
@.str.8 = [47 x i8] c" contains an entry with invalid row index %8d\0A\00"
@.str.9 = [19 x i8] c" Column %8d\00"
@.str.10 = [50 x i8] c" contains two or more entries with row index %8d\0A\00"
@.str.11 = [69 x i8] c" ****** Input parameters for MC64A/AD: JOB = %8d, N = %d, NE = %8d\0A\00"
@.str.12 = [16 x i8] c" IP(1:N+1) = \00"
@.str.13 = [4 x i8] c"%8d\00"
@.str.14 = [2 x i8] c"\0A\00"
@.str.15 = [15 x i8] c"\0A IRN(1:NE) = \00"
@.str.16 = [16 x i8] c" A(1:NE) = \00"
@.str.17 = [7 x i8] c"%f14.4\00"
@.str.18 = [53 x i8] c" ****** Warning from MC64A/AD. Need to link mc21ad.\0A\00"
@.str.19 = [45 x i8] c" ****** Warning from MC64A/AD. INFO(1) = %2d\00"
@.str.20 = [39 x i8] c" The matrix is structurally singular.\0A\00"
@.str.21 = [46 x i8] c" ****** Warning from MC64A/AD. INFO(1) = %2d\0A\00"
@.str.22 = [48 x i8] c" Some scaling factors may be too large.\0A\00"
@.str.23 = [61 x i8] c" ****** Output parameters for MC64A/AD: INFO(1:2) = %8d%8d\0A\00"
@.str.24 = [15 x i8] c" NUM = \00"
@.str.25 = [15 x i8] c" CPERM(1:N) = \00"
@.str.26 = [16 x i8] c"\0A DW(1:N) = \00"
@.str.27 = [7 x i8] c"%11.3f\00"
@.str.28 = [16 x i8] c"\0A DW(N+1:2N) = \00"
define i32 @mc64ad_(i32* %0, i32* %1, i32* %2, i32* %3, i32* %4, double* %5, i32* %6, i32* %7, i32* %8, i32* %9, i32* %10, double* %11, i32* %12, i32* %13) {
%15 = alloca i32*
%16 = alloca i32*
%17 = alloca i32*
%18 = alloca i32*
%19 = alloca i32*
%20 = alloca double*
%21 = alloca i32*
%22 = alloca i32*
%23 = alloca i32*
%24 = alloca i32*
%25 = alloca i32*
%26 = alloca double*
%27 = alloca i32*
%28 = alloca i32*
%29 = alloca i32
%30 = alloca i32
%31 = alloca double
%32 = alloca double
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca double
%37 = alloca double
store i32* %0, i32** %15
store i32* %1, i32** %16
store i32* %2, i32** %17
store i32* %3, i32** %18
store i32* %4, i32** %19
store double* %5, double** %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 double* %11, double** %26
store i32* %12, i32** %27
store i32* %13, i32** %28
%38 = load i32*, i32** %22
%39 = getelementptr inbounds i32, i32* %38, i32 -1
store i32* %39, i32** %22
%40 = load i32*, i32** %18
%41 = getelementptr inbounds i32, i32* %40, i32 -1
store i32* %41, i32** %18
%42 = load double*, double** %20
%43 = getelementptr inbounds double, double* %42, i32 -1
store double* %43, double** %20
%44 = load i32*, i32** %19
%45 = getelementptr inbounds i32, i32* %44, i32 -1
store i32* %45, i32** %19
%46 = load i32*, i32** %24
%47 = getelementptr inbounds i32, i32* %46, i32 -1
store i32* %47, i32** %24
%48 = load double*, double** %26
%49 = getelementptr inbounds double, double* %48, i32 -1
store double* %49, double** %26
%50 = load i32*, i32** %27
%51 = getelementptr inbounds i32, i32* %50, i32 -1
store i32* %51, i32** %27
%52 = load i32*, i32** %28
%53 = getelementptr inbounds i32, i32* %52, i32 -1
store i32* %53, i32** %28
%54 = call i32 (i8*, ...) bitcast (i32 (...)* @dlamch_ to i32 (i8*, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%55 = sitofp i32 %54 to double
store double %55, double* %37
%56 = load i32*, i32** %15
%57 = load i32, i32* %56
%58 = icmp slt i32 %57, 1
br i1 %58, label %63, label %59
59: ; preds = %14
%60 = load i32*, i32** %15
%61 = load i32, i32* %60
%62 = icmp sgt i32 %61, 5
br i1 %62, label %63, label %82
63: ; preds = %59, %14
%64 = load i32*, i32** %28
%65 = getelementptr inbounds i32, i32* %64, i64 1
store i32 -1, i32* %65
%66 = load i32*, i32** %15
%67 = load i32, i32* %66
%68 = load i32*, i32** %28
%69 = getelementptr inbounds i32, i32* %68, i64 2
store i32 %67, i32* %69
%70 = load i32*, i32** %27
%71 = getelementptr inbounds i32, i32* %70, i64 1
%72 = load i32, i32* %71
%73 = icmp sge i32 %72, 0
br i1 %73, label %74, label %81
74: ; preds = %63
%75 = load i32*, i32** %28
%76 = getelementptr inbounds i32, i32* %75, i64 1
%77 = load i32, i32* %76
%78 = load i32*, i32** %15
%79 = load i32, i32* %78
%80 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.1, i64 0, i64 0), i32 %77, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0), i32 %79)
br label %81
81: ; preds = %74, %63
br label %1298
82: ; preds = %59
%83 = load i32*, i32** %16
%84 = load i32, i32* %83
%85 = icmp slt i32 %84, 1
br i1 %85, label %86, label %105
86: ; preds = %82
%87 = load i32*, i32** %28
%88 = getelementptr inbounds i32, i32* %87, i64 1
store i32 -2, i32* %88
%89 = load i32*, i32** %16
%90 = load i32, i32* %89
%91 = load i32*, i32** %28
%92 = getelementptr inbounds i32, i32* %91, i64 2
store i32 %90, i32* %92
%93 = load i32*, i32** %27
%94 = getelementptr inbounds i32, i32* %93, i64 1
%95 = load i32, i32* %94
%96 = icmp sge i32 %95, 0
br i1 %96, label %97, label %104
97: ; preds = %86
%98 = load i32*, i32** %28
%99 = getelementptr inbounds i32, i32* %98, i64 1
%100 = load i32, i32* %99
%101 = load i32*, i32** %15
%102 = load i32, i32* %101
%103 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.1, i64 0, i64 0), i32 %100, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.3, i64 0, i64 0), i32 %102)
br label %104
104: ; preds = %97, %86
br label %1298
105: ; preds = %82
%106 = load i32*, i32** %17
%107 = load i32, i32* %106
%108 = icmp slt i32 %107, 1
br i1 %108, label %109, label %128
109: ; preds = %105
%110 = load i32*, i32** %28
%111 = getelementptr inbounds i32, i32* %110, i64 1
store i32 -3, i32* %111
%112 = load i32*, i32** %17
%113 = load i32, i32* %112
%114 = load i32*, i32** %28
%115 = getelementptr inbounds i32, i32* %114, i64 2
store i32 %113, i32* %115
%116 = load i32*, i32** %27
%117 = getelementptr inbounds i32, i32* %116, i64 1
%118 = load i32, i32* %117
%119 = icmp sge i32 %118, 0
br i1 %119, label %120, label %127
120: ; preds = %109
%121 = load i32*, i32** %28
%122 = getelementptr inbounds i32, i32* %121, i64 1
%123 = load i32, i32* %122
%124 = load i32*, i32** %15
%125 = load i32, i32* %124
%126 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.1, i64 0, i64 0), i32 %123, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.4, i64 0, i64 0), i32 %125)
br label %127
127: ; preds = %120, %109
br label %1298
128: ; preds = %105
%129 = load i32*, i32** %15
%130 = load i32, i32* %129
%131 = icmp eq i32 %130, 1
br i1 %131, label %132, label %136
132: ; preds = %128
%133 = load i32*, i32** %16
%134 = load i32, i32* %133
%135 = mul nsw i32 %134, 5
store i32 %135, i32* %35
br label %136
136: ; preds = %132, %128
%137 = load i32*, i32** %15
%138 = load i32, i32* %137
%139 = icmp eq i32 %138, 2
br i1 %139, label %140, label %144
140: ; preds = %136
%141 = load i32*, i32** %16
%142 = load i32, i32* %141
%143 = shl i32 %142, 2
store i32 %143, i32* %35
br label %144
144: ; preds = %140, %136
%145 = load i32*, i32** %15
%146 = load i32, i32* %145
%147 = icmp eq i32 %146, 3
br i1 %147, label %148, label %155
148: ; preds = %144
%149 = load i32*, i32** %16
%150 = load i32, i32* %149
%151 = mul nsw i32 %150, 10
%152 = load i32*, i32** %17
%153 = load i32, i32* %152
%154 = add nsw i32 %151, %153
store i32 %154, i32* %35
br label %155
155: ; preds = %148, %144
%156 = load i32*, i32** %15
%157 = load i32, i32* %156
%158 = icmp eq i32 %157, 4
br i1 %158, label %159, label %163
159: ; preds = %155
%160 = load i32*, i32** %16
%161 = load i32, i32* %160
%162 = mul nsw i32 %161, 5
store i32 %162, i32* %35
br label %163
163: ; preds = %159, %155
%164 = load i32*, i32** %15
%165 = load i32, i32* %164
%166 = icmp eq i32 %165, 5
br i1 %166, label %167, label %171
167: ; preds = %163
%168 = load i32*, i32** %16
%169 = load i32, i32* %168
%170 = mul nsw i32 %169, 5
store i32 %170, i32* %35
br label %171
171: ; preds = %167, %163
%172 = load i32*, i32** %23
%173 = load i32, i32* %172
%174 = load i32, i32* %35
%175 = icmp slt i32 %173, %174
br i1 %175, label %176, label %193
176: ; preds = %171
%177 = load i32*, i32** %28
%178 = getelementptr inbounds i32, i32* %177, i64 1
store i32 -4, i32* %178
%179 = load i32, i32* %35
%180 = load i32*, i32** %28
%181 = getelementptr inbounds i32, i32* %180, i64 2
store i32 %179, i32* %181
%182 = load i32*, i32** %27
%183 = getelementptr inbounds i32, i32* %182, i64 1
%184 = load i32, i32* %183
%185 = icmp sge i32 %184, 0
br i1 %185, label %186, label %192
186: ; preds = %176
%187 = load i32*, i32** %28
%188 = getelementptr inbounds i32, i32* %187, i64 1
%189 = load i32, i32* %188
%190 = load i32, i32* %35
%191 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.1, i64 0, i64 0), i32 %189, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.5, i64 0, i64 0), i32 %190)
br label %192
192: ; preds = %186, %176
br label %1298
193: ; preds = %171
%194 = load i32*, i32** %15
%195 = load i32, i32* %194
%196 = icmp sgt i32 %195, 1
br i1 %196, label %197, label %256
197: ; preds = %193
%198 = load i32*, i32** %15
%199 = load i32, i32* %198
%200 = icmp eq i32 %199, 2
br i1 %200, label %201, label %204
201: ; preds = %197
%202 = load i32*, i32** %16
%203 = load i32, i32* %202
store i32 %203, i32* %35
br label %204
204: ; preds = %201, %197
%205 = load i32*, i32** %15
%206 = load i32, i32* %205
%207 = icmp eq i32 %206, 3
br i1 %207, label %208, label %211
208: ; preds = %204
%209 = load i32*, i32** %17
%210 = load i32, i32* %209
store i32 %210, i32* %35
br label %211
211: ; preds = %208, %204
%212 = load i32*, i32** %15
%213 = load i32, i32* %212
%214 = icmp eq i32 %213, 4
br i1 %214, label %215, label %222
215: ; preds = %211
%216 = load i32*, i32** %16
%217 = load i32, i32* %216
%218 = shl i32 %217, 1
%219 = load i32*, i32** %17
%220 = load i32, i32* %219
%221 = add nsw i32 %218, %220
store i32 %221, i32* %35
br label %222
222: ; preds = %215, %211
%223 = load i32*, i32** %15
%224 = load i32, i32* %223
%225 = icmp eq i32 %224, 5
br i1 %225, label %226, label %233
226: ; preds = %222
%227 = load i32*, i32** %16
%228 = load i32, i32* %227
%229 = mul nsw i32 %228, 3
%230 = load i32*, i32** %17
%231 = load i32, i32* %230
%232 = add nsw i32 %229, %231
store i32 %232, i32* %35
br label %233
233: ; preds = %226, %222
%234 = load i32*, i32** %25
%235 = load i32, i32* %234
%236 = load i32, i32* %35
%237 = icmp slt i32 %235, %236
br i1 %237, label %238, label %255
238: ; preds = %233
%239 = load i32*, i32** %28
%240 = getelementptr inbounds i32, i32* %239, i64 1
store i32 -5, i32* %240
%241 = load i32, i32* %35
%242 = load i32*, i32** %28
%243 = getelementptr inbounds i32, i32* %242, i64 2
store i32 %241, i32* %243
%244 = load i32*, i32** %27
%245 = getelementptr inbounds i32, i32* %244, i64 1
%246 = load i32, i32* %245
%247 = icmp sge i32 %246, 0
br i1 %247, label %248, label %254
248: ; preds = %238
%249 = load i32*, i32** %28
%250 = getelementptr inbounds i32, i32* %249, i64 1
%251 = load i32, i32* %250
%252 = load i32, i32* %35
%253 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.1, i64 0, i64 0), i32 %251, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.6, i64 0, i64 0), i32 %252)
br label %254
254: ; preds = %248, %238
br label %1298
255: ; preds = %233
br label %256
256: ; preds = %255, %193
%257 = load i32*, i32** %27
%258 = getelementptr inbounds i32, i32* %257, i64 4
%259 = load i32, i32* %258
%260 = icmp eq i32 %259, 0
br i1 %260, label %261, label %372
261: ; preds = %256
%262 = load i32*, i32** %16
%263 = load i32, i32* %262
store i32 %263, i32* %29
store i32 1, i32* %33
br label %264
264: ; preds = %273, %261
%265 = load i32, i32* %33
%266 = load i32, i32* %29
%267 = icmp sle i32 %265, %266
br i1 %267, label %268, label %276
268: ; preds = %264
%269 = load i32*, i32** %24
%270 = load i32, i32* %33
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds i32, i32* %269, i64 %271
store i32 0, i32* %272
br label %273
273: ; preds = %268
%274 = load i32, i32* %33
%275 = add nsw i32 %274, 1
store i32 %275, i32* %33
br label %264
276: ; preds = %264
%277 = load i32*, i32** %16
%278 = load i32, i32* %277
store i32 %278, i32* %29
store i32 1, i32* %34
br label %279
279: ; preds = %368, %276
%280 = load i32, i32* %34
%281 = load i32, i32* %29
%282 = icmp sle i32 %280, %281
br i1 %282, label %283, label %371
283: ; preds = %279
%284 = load i32*, i32** %18
%285 = load i32, i32* %34
%286 = add nsw i32 %285, 1
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds i32, i32* %284, i64 %287
%289 = load i32, i32* %288
%290 = sub nsw i32 %289, 1
store i32 %290, i32* %30
%291 = load i32*, i32** %18
%292 = load i32, i32* %34
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds i32, i32* %291, i64 %293
%295 = load i32, i32* %294
store i32 %295, i32* %35
br label %296
296: ; preds = %364, %283
%297 = load i32, i32* %35
%298 = load i32, i32* %30
%299 = icmp sle i32 %297, %298
br i1 %299, label %300, label %367
300: ; preds = %296
%301 = load i32*, i32** %19
%302 = load i32, i32* %35
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds i32, i32* %301, i64 %303
%305 = load i32, i32* %304
store i32 %305, i32* %33
%306 = load i32, i32* %33
%307 = icmp slt i32 %306, 1
br i1 %307, label %313, label %308
308: ; preds = %300
%309 = load i32, i32* %33
%310 = load i32*, i32** %16
%311 = load i32, i32* %310
%312 = icmp sgt i32 %309, %311
br i1 %312, label %313, label %331
313: ; preds = %308, %300
%314 = load i32*, i32** %28
%315 = getelementptr inbounds i32, i32* %314, i64 1
store i32 -6, i32* %315
%316 = load i32, i32* %34
%317 = load i32*, i32** %28
%318 = getelementptr inbounds i32, i32* %317, i64 2
store i32 %316, i32* %318
%319 = load i32*, i32** %27
%320 = getelementptr inbounds i32, i32* %319, i64 1
%321 = load i32, i32* %320
%322 = icmp sge i32 %321, 0
br i1 %322, label %323, label %330
323: ; preds = %313
%324 = load i32*, i32** %28
%325 = getelementptr inbounds i32, i32* %324, i64 1
%326 = load i32, i32* %325
%327 = load i32, i32* %34
%328 = load i32, i32* %33
%329 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.1, i64 0, i64 0), i32 %326, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.7, i64 0, i64 0), i32 %327, i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.8, i64 0, i64 0), i32 %328)
br label %330
330: ; preds = %323, %313
br label %1298
331: ; preds = %308
%332 = load i32*, i32** %24
%333 = load i32, i32* %33
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds i32, i32* %332, i64 %334
%336 = load i32, i32* %335
%337 = load i32, i32* %34
%338 = icmp eq i32 %336, %337
br i1 %338, label %339, label %357
339: ; preds = %331
%340 = load i32*, i32** %28
%341 = getelementptr inbounds i32, i32* %340, i64 1
store i32 -7, i32* %341
%342 = load i32, i32* %34
%343 = load i32*, i32** %28
%344 = getelementptr inbounds i32, i32* %343, i64 2
store i32 %342, i32* %344
%345 = load i32*, i32** %27
%346 = getelementptr inbounds i32, i32* %345, i64 1
%347 = load i32, i32* %346
%348 = icmp sge i32 %347, 0
br i1 %348, label %349, label %356
349: ; preds = %339
%350 = load i32*, i32** %28
%351 = getelementptr inbounds i32, i32* %350, i64 1
%352 = load i32, i32* %351
%353 = load i32, i32* %34
%354 = load i32, i32* %33
%355 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.1, i64 0, i64 0), i32 %352, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.9, i64 0, i64 0), i32 %353, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.10, i64 0, i64 0), i32 %354)
br label %356
356: ; preds = %349, %339
br label %1298
357: ; preds = %331
%358 = load i32, i32* %34
%359 = load i32*, i32** %24
%360 = load i32, i32* %33
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds i32, i32* %359, i64 %361
store i32 %358, i32* %362
br label %363
363: ; preds = %357
br label %364
364: ; preds = %363
%365 = load i32, i32* %35
%366 = add nsw i32 %365, 1
store i32 %366, i32* %35
br label %296
367: ; preds = %296
br label %368
368: ; preds = %367
%369 = load i32, i32* %34
%370 = add nsw i32 %369, 1
store i32 %370, i32* %34
br label %279
371: ; preds = %279
br label %372
372: ; preds = %371, %256
%373 = load i32*, i32** %27
%374 = getelementptr inbounds i32, i32* %373, i64 3
%375 = load i32, i32* %374
%376 = icmp sge i32 %375, 0
br i1 %376, label %377, label %462
377: ; preds = %372
%378 = load i32*, i32** %15
%379 = load i32, i32* %378
%380 = load i32*, i32** %16
%381 = load i32, i32* %380
%382 = load i32*, i32** %17
%383 = load i32, i32* %382
%384 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.11, i64 0, i64 0), i32 %379, i32 %381, i32 %383)
%385 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.12, i64 0, i64 0))
store i32 1, i32* %34
br label %386
386: ; preds = %405, %377
%387 = load i32, i32* %34
%388 = load i32*, i32** %16
%389 = load i32, i32* %388
%390 = add nsw i32 %389, 1
%391 = icmp sle i32 %387, %390
br i1 %391, label %392, label %408
392: ; preds = %386
%393 = load i32*, i32** %18
%394 = load i32, i32* %34
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds i32, i32* %393, i64 %395
%397 = load i32, i32* %396
%398 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.13, i64 0, i64 0), i32 %397)
%399 = load i32, i32* %34
%400 = srem i32 %399, 8
%401 = icmp eq i32 %400, 0
br i1 %401, label %402, label %404
402: ; preds = %392
%403 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0))
br label %404
404: ; preds = %402, %392
br label %405
405: ; preds = %404
%406 = load i32, i32* %34
%407 = add nsw i32 %406, 1
store i32 %407, i32* %34
br label %386
408: ; preds = %386
%409 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.15, i64 0, i64 0))
store i32 1, i32* %34
br label %410
410: ; preds = %428, %408
%411 = load i32, i32* %34
%412 = load i32*, i32** %17
%413 = load i32, i32* %412
%414 = icmp sle i32 %411, %413
br i1 %414, label %415, label %431
415: ; preds = %410
%416 = load i32*, i32** %19
%417 = load i32, i32* %34
%418 = sext i32 %417 to i64
%419 = getelementptr inbounds i32, i32* %416, i64 %418
%420 = load i32, i32* %419
%421 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.13, i64 0, i64 0), i32 %420)
%422 = load i32, i32* %34
%423 = srem i32 %422, 8
%424 = icmp eq i32 %423, 0
br i1 %424, label %425, label %427
425: ; preds = %415
%426 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0))
br label %427
427: ; preds = %425, %415
br label %428
428: ; preds = %427
%429 = load i32, i32* %34
%430 = add nsw i32 %429, 1
store i32 %430, i32* %34
br label %410
431: ; preds = %410
%432 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0))
%433 = load i32*, i32** %15
%434 = load i32, i32* %433
%435 = icmp sgt i32 %434, 1
br i1 %435, label %436, label %461
436: ; preds = %431
%437 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.16, i64 0, i64 0))
store i32 1, i32* %34
br label %438
438: ; preds = %456, %436
%439 = load i32, i32* %34
%440 = load i32*, i32** %17
%441 = load i32, i32* %440
%442 = icmp sle i32 %439, %441
br i1 %442, label %443, label %459
443: ; preds = %438
%444 = load double*, double** %20
%445 = load i32, i32* %34
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds double, double* %444, i64 %446
%448 = load double, double* %447
%449 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.17, i64 0, i64 0), double %448)
%450 = load i32, i32* %34
%451 = srem i32 %450, 4
%452 = icmp eq i32 %451, 0
br i1 %452, label %453, label %455
453: ; preds = %443
%454 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0))
br label %455
455: ; preds = %453, %443
br label %456
456: ; preds = %455
%457 = load i32, i32* %34
%458 = add nsw i32 %457, 1
store i32 %458, i32* %34
br label %438
459: ; preds = %438
%460 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0))
br label %461
461: ; preds = %459, %431
br label %462
462: ; preds = %461, %372
store i32 1, i32* %33
br label %463
463: ; preds = %471, %462
%464 = load i32, i32* %33
%465 = icmp sle i32 %464, 10
br i1 %465, label %466, label %474
466: ; preds = %463
%467 = load i32*, i32** %28
%468 = load i32, i32* %33
%469 = sext i32 %468 to i64
%470 = getelementptr inbounds i32, i32* %467, i64 %469
store i32 0, i32* %470
br label %471
471: ; preds = %466
%472 = load i32, i32* %33
%473 = add nsw i32 %472, 1
store i32 %473, i32* %33
br label %463
474: ; preds = %463
%475 = load i32*, i32** %15
%476 = load i32, i32* %475
%477 = icmp eq i32 %476, 1
br i1 %477, label %478, label %507
478: ; preds = %474
%479 = load i32*, i32** %16
%480 = load i32, i32* %479
store i32 %480, i32* %29
store i32 1, i32* %34
br label %481
481: ; preds = %502, %478
%482 = load i32, i32* %34
%483 = load i32, i32* %29
%484 = icmp sle i32 %482, %483
br i1 %484, label %485, label %505
485: ; preds = %481
%486 = load i32*, i32** %18
%487 = load i32, i32* %34
%488 = add nsw i32 %487, 1
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds i32, i32* %486, i64 %489
%491 = load i32, i32* %490
%492 = load i32*, i32** %18
%493 = load i32, i32* %34
%494 = sext i32 %493 to i64
%495 = getelementptr inbounds i32, i32* %492, i64 %494
%496 = load i32, i32* %495
%497 = sub nsw i32 %491, %496
%498 = load i32*, i32** %24
%499 = load i32, i32* %34
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds i32, i32* %498, i64 %500
store i32 %497, i32* %501
br label %502
502: ; preds = %485
%503 = load i32, i32* %34
%504 = add nsw i32 %503, 1
store i32 %504, i32* %34
br label %481
505: ; preds = %481
%506 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.18, i64 0, i64 0))
br label %1163
507: ; preds = %474
%508 = load i32*, i32** %15
%509 = load i32, i32* %508
%510 = icmp eq i32 %509, 2
br i1 %510, label %511, label %548
511: ; preds = %507
%512 = load i32*, i32** %16
%513 = load i32*, i32** %17
%514 = load i32*, i32** %18
%515 = getelementptr inbounds i32, i32* %514, i64 1
%516 = load i32*, i32** %19
%517 = getelementptr inbounds i32, i32* %516, i64 1
%518 = load double*, double** %20
%519 = getelementptr inbounds double, double* %518, i64 1
%520 = load i32*, i32** %22
%521 = getelementptr inbounds i32, i32* %520, i64 1
%522 = load i32*, i32** %21
%523 = load i32*, i32** %24
%524 = getelementptr inbounds i32, i32* %523, i64 1
%525 = load i32*, i32** %24
%526 = load i32*, i32** %16
%527 = load i32, i32* %526
%528 = add nsw i32 %527, 1
%529 = sext i32 %528 to i64
%530 = getelementptr inbounds i32, i32* %525, i64 %529
%531 = load i32*, i32** %24
%532 = load i32*, i32** %16
%533 = load i32, i32* %532
%534 = shl i32 %533, 1
%535 = add nsw i32 %534, 1
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds i32, i32* %531, i64 %536
%538 = load i32*, i32** %24
%539 = load i32*, i32** %16
%540 = load i32, i32* %539
%541 = mul nsw i32 %540, 3
%542 = add nsw i32 %541, 1
%543 = sext i32 %542 to i64
%544 = getelementptr inbounds i32, i32* %538, i64 %543
%545 = load double*, double** %26
%546 = getelementptr inbounds double, double* %545, i64 1
%547 = call i32 @mc64bd_(i32* %512, i32* %513, i32* %515, i32* %517, double* %519, i32* %521, i32* %522, i32* %524, i32* %530, i32* %537, i32* %544, double* %546)
br label %1163
548: ; preds = %507
%549 = load i32*, i32** %15
%550 = load i32, i32* %549
%551 = icmp eq i32 %550, 3
br i1 %551, label %552, label %677
552: ; preds = %548
%553 = load i32*, i32** %17
%554 = load i32, i32* %553
store i32 %554, i32* %29
store i32 1, i32* %35
br label %555
555: ; preds = %587, %552
%556 = load i32, i32* %35
%557 = load i32, i32* %29
%558 = icmp sle i32 %556, %557
br i1 %558, label %559, label %590
559: ; preds = %555
%560 = load i32*, i32** %19
%561 = load i32, i32* %35
%562 = sext i32 %561 to i64
%563 = getelementptr inbounds i32, i32* %560, i64 %562
%564 = load i32, i32* %563
%565 = load i32*, i32** %24
%566 = load i32, i32* %35
%567 = sext i32 %566 to i64
%568 = getelementptr inbounds i32, i32* %565, i64 %567
store i32 %564, i32* %568
%569 = load double*, double** %20
%570 = load i32, i32* %35
%571 = sext i32 %570 to i64
%572 = getelementptr inbounds double, double* %569, i64 %571
%573 = load double, double* %572
store double %573, double* %31
%574 = load double, double* %31
%575 = fcmp oge double %574, 0.000000e+00
br i1 %575, label %576, label %578
576: ; preds = %559
%577 = load double, double* %31
br label %581
578: ; preds = %559
%579 = load double, double* %31
%580 = fneg double %579
br label %581
581: ; preds = %578, %576
%582 = phi double [ %577, %576 ], [ %580, %578 ]
%583 = load double*, double** %26
%584 = load i32, i32* %35
%585 = sext i32 %584 to i64
%586 = getelementptr inbounds double, double* %583, i64 %585
store double %582, double* %586
br label %587
587: ; preds = %581
%588 = load i32, i32* %35
%589 = add nsw i32 %588, 1
store i32 %589, i32* %35
br label %555
590: ; preds = %555
%591 = load i32*, i32** %16
%592 = load i32*, i32** %17
%593 = load i32*, i32** %18
%594 = getelementptr inbounds i32, i32* %593, i64 1
%595 = load i32*, i32** %24
%596 = getelementptr inbounds i32, i32* %595, i64 1
%597 = load double*, double** %26
%598 = getelementptr inbounds double, double* %597, i64 1
%599 = call i32 @mc64rd_(i32* %591, i32* %592, i32* %594, i32* %596, double* %598)
%600 = load i32*, i32** %16
%601 = load i32*, i32** %17
%602 = load i32*, i32** %18
%603 = getelementptr inbounds i32, i32* %602, i64 1
%604 = load i32*, i32** %24
%605 = getelementptr inbounds i32, i32* %604, i64 1
%606 = load double*, double** %26
%607 = getelementptr inbounds double, double* %606, i64 1
%608 = load i32*, i32** %22
%609 = getelementptr inbounds i32, i32* %608, i64 1
%610 = load i32*, i32** %21
%611 = load i32*, i32** %24
%612 = load i32*, i32** %17
%613 = load i32, i32* %612
%614 = add nsw i32 %613, 1
%615 = sext i32 %614 to i64
%616 = getelementptr inbounds i32, i32* %611, i64 %615
%617 = load i32*, i32** %24
%618 = load i32*, i32** %17
%619 = load i32, i32* %618
%620 = load i32*, i32** %16
%621 = load i32, i32* %620
%622 = add nsw i32 %619, %621
%623 = add nsw i32 %622, 1
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds i32, i32* %617, i64 %624
%626 = load i32*, i32** %24
%627 = load i32*, i32** %17
%628 = load i32, i32* %627
%629 = load i32*, i32** %16
%630 = load i32, i32* %629
%631 = shl i32 %630, 1
%632 = add nsw i32 %628, %631
%633 = add nsw i32 %632, 1
%634 = sext i32 %633 to i64
%635 = getelementptr inbounds i32, i32* %626, i64 %634
%636 = load i32*, i32** %24
%637 = load i32*, i32** %17
%638 = load i32, i32* %637
%639 = load i32*, i32** %16
%640 = load i32, i32* %639
%641 = mul nsw i32 %640, 3
%642 = add nsw i32 %638, %641
%643 = add nsw i32 %642, 1
%644 = sext i32 %643 to i64
%645 = getelementptr inbounds i32, i32* %636, i64 %644
%646 = load i32*, i32** %24
%647 = load i32*, i32** %17
%648 = load i32, i32* %647
%649 = load i32*, i32** %16
%650 = load i32, i32* %649
%651 = shl i32 %650, 2
%652 = add nsw i32 %648, %651
%653 = add nsw i32 %652, 1
%654 = sext i32 %653 to i64
%655 = getelementptr inbounds i32, i32* %646, i64 %654
%656 = load i32*, i32** %24
%657 = load i32*, i32** %17
%658 = load i32, i32* %657
%659 = load i32*, i32** %16
%660 = load i32, i32* %659
%661 = mul nsw i32 %660, 5
%662 = add nsw i32 %658, %661
%663 = add nsw i32 %662, 1
%664 = sext i32 %663 to i64
%665 = getelementptr inbounds i32, i32* %656, i64 %664
%666 = load i32*, i32** %24
%667 = load i32*, i32** %17
%668 = load i32, i32* %667
%669 = load i32*, i32** %16
%670 = load i32, i32* %669
%671 = mul nsw i32 %670, 6
%672 = add nsw i32 %668, %671
%673 = add nsw i32 %672, 1
%674 = sext i32 %673 to i64
%675 = getelementptr inbounds i32, i32* %666, i64 %674
%676 = call i32 @mc64sd_(i32* %600, i32* %601, i32* %603, i32* %605, double* %607, i32* %609, i32* %610, i32* %616, i32* %625, i32* %635, i32* %645, i32* %655, i32* %665, i32* %675)
br label %1163
677: ; preds = %548
%678 = load i32*, i32** %15
%679 = load i32, i32* %678
%680 = icmp eq i32 %679, 4
br i1 %680, label %681, label %845
681: ; preds = %677
%682 = load i32*, i32** %16
%683 = load i32, i32* %682
store i32 %683, i32* %29
store i32 1, i32* %34
br label %684
684: ; preds = %787, %681
%685 = load i32, i32* %34
%686 = load i32, i32* %29
%687 = icmp sle i32 %685, %686
br i1 %687, label %688, label %790
688: ; preds = %684
store double 0.000000e+00, double* %36
%689 = load i32*, i32** %18
%690 = load i32, i32* %34
%691 = add nsw i32 %690, 1
%692 = sext i32 %691 to i64
%693 = getelementptr inbounds i32, i32* %689, i64 %692
%694 = load i32, i32* %693
%695 = sub nsw i32 %694, 1
store i32 %695, i32* %30
%696 = load i32*, i32** %18
%697 = load i32, i32* %34
%698 = sext i32 %697 to i64
%699 = getelementptr inbounds i32, i32* %696, i64 %698
%700 = load i32, i32* %699
store i32 %700, i32* %35
br label %701
701: ; preds = %738, %688
%702 = load i32, i32* %35
%703 = load i32, i32* %30
%704 = icmp sle i32 %702, %703
br i1 %704, label %705, label %741
705: ; preds = %701
%706 = load double*, double** %20
%707 = load i32, i32* %35
%708 = sext i32 %707 to i64
%709 = getelementptr inbounds double, double* %706, i64 %708
%710 = load double, double* %709
store double %710, double* %31
%711 = load double, double* %31
%712 = fcmp oge double %711, 0.000000e+00
br i1 %712, label %713, label %715
713: ; preds = %705
%714 = load double, double* %31
br label %718
715: ; preds = %705
%716 = load double, double* %31
%717 = fneg double %716
br label %718
718: ; preds = %715, %713
%719 = phi double [ %714, %713 ], [ %717, %715 ]
%720 = load double, double* %36
%721 = fcmp ogt double %719, %720
br i1 %721, label %722, label %737
722: ; preds = %718
%723 = load double*, double** %20
%724 = load i32, i32* %35
%725 = sext i32 %724 to i64
%726 = getelementptr inbounds double, double* %723, i64 %725
%727 = load double, double* %726
store double %727, double* %32
%728 = load double, double* %32
%729 = fcmp oge double %728, 0.000000e+00
br i1 %729, label %730, label %732
730: ; preds = %722
%731 = load double, double* %32
br label %735
732: ; preds = %722
%733 = load double, double* %32
%734 = fneg double %733
br label %735
735: ; preds = %732, %730
%736 = phi double [ %731, %730 ], [ %734, %732 ]
store double %736, double* %36
br label %737
737: ; preds = %735, %718
br label %738
738: ; preds = %737
%739 = load i32, i32* %35
%740 = add nsw i32 %739, 1
store i32 %740, i32* %35
br label %701
741: ; preds = %701
%742 = load i32*, i32** %18
%743 = load i32, i32* %34
%744 = add nsw i32 %743, 1
%745 = sext i32 %744 to i64
%746 = getelementptr inbounds i32, i32* %742, i64 %745
%747 = load i32, i32* %746
%748 = sub nsw i32 %747, 1
store i32 %748, i32* %30
%749 = load i32*, i32** %18
%750 = load i32, i32* %34
%751 = sext i32 %750 to i64
%752 = getelementptr inbounds i32, i32* %749, i64 %751
%753 = load i32, i32* %752
store i32 %753, i32* %35
br label %754
754: ; preds = %783, %741
%755 = load i32, i32* %35
%756 = load i32, i32* %30
%757 = icmp sle i32 %755, %756
br i1 %757, label %758, label %786
758: ; preds = %754
%759 = load double, double* %36
%760 = load double*, double** %20
%761 = load i32, i32* %35
%762 = sext i32 %761 to i64
%763 = getelementptr inbounds double, double* %760, i64 %762
%764 = load double, double* %763
store double %764, double* %31
%765 = load double, double* %31
%766 = fcmp oge double %765, 0.000000e+00
br i1 %766, label %767, label %769
767: ; preds = %758
%768 = load double, double* %31
br label %772
769: ; preds = %758
%770 = load double, double* %31
%771 = fneg double %770
br label %772
772: ; preds = %769, %767
%773 = phi double [ %768, %767 ], [ %771, %769 ]
%774 = fsub double %759, %773
%775 = load double*, double** %26
%776 = load i32*, i32** %16
%777 = load i32, i32* %776
%778 = shl i32 %777, 1
%779 = load i32, i32* %35
%780 = add nsw i32 %778, %779
%781 = sext i32 %780 to i64
%782 = getelementptr inbounds double, double* %775, i64 %781
store double %774, double* %782
br label %783
783: ; preds = %772
%784 = load i32, i32* %35
%785 = add nsw i32 %784, 1
store i32 %785, i32* %35
br label %754
786: ; preds = %754
br label %787
787: ; preds = %786
%788 = load i32, i32* %34
%789 = add nsw i32 %788, 1
store i32 %789, i32* %34
br label %684
790: ; preds = %684
%791 = load i32*, i32** %16
%792 = load i32*, i32** %17
%793 = load i32*, i32** %18
%794 = getelementptr inbounds i32, i32* %793, i64 1
%795 = load i32*, i32** %19
%796 = getelementptr inbounds i32, i32* %795, i64 1
%797 = load double*, double** %26
%798 = load i32*, i32** %16
%799 = load i32, i32* %798
%800 = shl i32 %799, 1
%801 = add nsw i32 %800, 1
%802 = sext i32 %801 to i64
%803 = getelementptr inbounds double, double* %797, i64 %802
%804 = load i32*, i32** %22
%805 = getelementptr inbounds i32, i32* %804, i64 1
%806 = load i32*, i32** %21
%807 = load i32*, i32** %24
%808 = getelementptr inbounds i32, i32* %807, i64 1
%809 = load i32*, i32** %24
%810 = load i32*, i32** %16
%811 = load i32, i32* %810
%812 = add nsw i32 %811, 1
%813 = sext i32 %812 to i64
%814 = getelementptr inbounds i32, i32* %809, i64 %813
%815 = load i32*, i32** %24
%816 = load i32*, i32** %16
%817 = load i32, i32* %816
%818 = shl i32 %817, 1
%819 = add nsw i32 %818, 1
%820 = sext i32 %819 to i64
%821 = getelementptr inbounds i32, i32* %815, i64 %820
%822 = load i32*, i32** %24
%823 = load i32*, i32** %16
%824 = load i32, i32* %823
%825 = mul nsw i32 %824, 3
%826 = add nsw i32 %825, 1
%827 = sext i32 %826 to i64
%828 = getelementptr inbounds i32, i32* %822, i64 %827
%829 = load i32*, i32** %24
%830 = load i32*, i32** %16
%831 = load i32, i32* %830
%832 = shl i32 %831, 2
%833 = add nsw i32 %832, 1
%834 = sext i32 %833 to i64
%835 = getelementptr inbounds i32, i32* %829, i64 %834
%836 = load double*, double** %26
%837 = getelementptr inbounds double, double* %836, i64 1
%838 = load double*, double** %26
%839 = load i32*, i32** %16
%840 = load i32, i32* %839
%841 = add nsw i32 %840, 1
%842 = sext i32 %841 to i64
%843 = getelementptr inbounds double, double* %838, i64 %842
%844 = call i32 @mc64wd_(i32* %791, i32* %792, i32* %794, i32* %796, double* %803, i32* %805, i32* %806, i32* %808, i32* %814, i32* %821, i32* %828, i32* %835, double* %837, double* %843)
br label %1163
845: ; preds = %677
%846 = load i32*, i32** %15
%847 = load i32, i32* %846
%848 = icmp eq i32 %847, 5
br i1 %848, label %849, label %1162
849: ; preds = %845
%850 = load i32*, i32** %16
%851 = load i32, i32* %850
store i32 %851, i32* %29
store i32 1, i32* %34
br label %852
852: ; preds = %1010, %849
%853 = load i32, i32* %34
%854 = load i32, i32* %29
%855 = icmp sle i32 %853, %854
br i1 %855, label %856, label %1013
856: ; preds = %852
store double 0.000000e+00, double* %36
%857 = load i32*, i32** %18
%858 = load i32, i32* %34
%859 = add nsw i32 %858, 1
%860 = sext i32 %859 to i64
%861 = getelementptr inbounds i32, i32* %857, i64 %860
%862 = load i32, i32* %861
%863 = sub nsw i32 %862, 1
store i32 %863, i32* %30
%864 = load i32*, i32** %18
%865 = load i32, i32* %34
%866 = sext i32 %865 to i64
%867 = getelementptr inbounds i32, i32* %864, i64 %866
%868 = load i32, i32* %867
store i32 %868, i32* %35
br label %869
869: ; preds = %918, %856
%870 = load i32, i32* %35
%871 = load i32, i32* %30
%872 = icmp sle i32 %870, %871
br i1 %872, label %873, label %921
873: ; preds = %869
%874 = load double*, double** %20
%875 = load i32, i32* %35
%876 = sext i32 %875 to i64
%877 = getelementptr inbounds double, double* %874, i64 %876
%878 = load double, double* %877
store double %878, double* %31
%879 = load double, double* %31
%880 = fcmp oge double %879, 0.000000e+00
br i1 %880, label %881, label %883
881: ; preds = %873
%882 = load double, double* %31
br label %886
883: ; preds = %873
%884 = load double, double* %31
%885 = fneg double %884
br label %886
886: ; preds = %883, %881
%887 = phi double [ %882, %881 ], [ %885, %883 ]
%888 = load double*, double** %26
%889 = load i32*, i32** %16
%890 = load i32, i32* %889
%891 = mul nsw i32 %890, 3
%892 = load i32, i32* %35
%893 = add nsw i32 %891, %892
%894 = sext i32 %893 to i64
%895 = getelementptr inbounds double, double* %888, i64 %894
store double %887, double* %895
%896 = load double*, double** %26
%897 = load i32*, i32** %16
%898 = load i32, i32* %897
%899 = mul nsw i32 %898, 3
%900 = load i32, i32* %35
%901 = add nsw i32 %899, %900
%902 = sext i32 %901 to i64
%903 = getelementptr inbounds double, double* %896, i64 %902
%904 = load double, double* %903
%905 = load double, double* %36
%906 = fcmp ogt double %904, %905
br i1 %906, label %907, label %917
907: ; preds = %886
%908 = load double*, double** %26
%909 = load i32*, i32** %16
%910 = load i32, i32* %909
%911 = mul nsw i32 %910, 3
%912 = load i32, i32* %35
%913 = add nsw i32 %911, %912
%914 = sext i32 %913 to i64
%915 = getelementptr inbounds double, double* %908, i64 %914
%916 = load double, double* %915
store double %916, double* %36
br label %917
917: ; preds = %907, %886
br label %918
918: ; preds = %917
%919 = load i32, i32* %35
%920 = add nsw i32 %919, 1
store i32 %920, i32* %35
br label %869
921: ; preds = %869
%922 = load double, double* %36
%923 = load double*, double** %26
%924 = load i32*, i32** %16
%925 = load i32, i32* %924
%926 = shl i32 %925, 1
%927 = load i32, i32* %34
%928 = add nsw i32 %926, %927
%929 = sext i32 %928 to i64
%930 = getelementptr inbounds double, double* %923, i64 %929
store double %922, double* %930
%931 = load double, double* %36
%932 = fcmp une double %931, 0.000000e+00
br i1 %932, label %933, label %936
933: ; preds = %921
%934 = load double, double* %36
%935 = call double @log(double %934)
store double %935, double* %36
br label %942
936: ; preds = %921
%937 = load double, double* %37
%938 = load i32*, i32** %16
%939 = load i32, i32* %938
%940 = sitofp i32 %939 to double
%941 = fdiv double %937, %940
store double %941, double* %36
br label %942
942: ; preds = %936, %933
%943 = load i32*, i32** %18
%944 = load i32, i32* %34
%945 = add nsw i32 %944, 1
%946 = sext i32 %945 to i64
%947 = getelementptr inbounds i32, i32* %943, i64 %946
%948 = load i32, i32* %947
%949 = sub nsw i32 %948, 1
store i32 %949, i32* %30
%950 = load i32*, i32** %18
%951 = load i32, i32* %34
%952 = sext i32 %951 to i64
%953 = getelementptr inbounds i32, i32* %950, i64 %952
%954 = load i32, i32* %953
store i32 %954, i32* %35
br label %955
955: ; preds = %1006, %942
%956 = load i32, i32* %35
%957 = load i32, i32* %30
%958 = icmp sle i32 %956, %957
br i1 %958, label %959, label %1009
959: ; preds = %955
%960 = load double*, double** %26
%961 = load i32*, i32** %16
%962 = load i32, i32* %961
%963 = mul nsw i32 %962, 3
%964 = load i32, i32* %35
%965 = add nsw i32 %963, %964
%966 = sext i32 %965 to i64
%967 = getelementptr inbounds double, double* %960, i64 %966
%968 = load double, double* %967
%969 = fcmp une double %968, 0.000000e+00
br i1 %969, label %970, label %991
970: ; preds = %959
%971 = load double, double* %36
%972 = load double*, double** %26
%973 = load i32*, i32** %16
%974 = load i32, i32* %973
%975 = mul nsw i32 %974, 3
%976 = load i32, i32* %35
%977 = add nsw i32 %975, %976
%978 = sext i32 %977 to i64
%979 = getelementptr inbounds double, double* %972, i64 %978
%980 = load double, double* %979
%981 = call double @log(double %980)
%982 = fsub double %971, %981
%983 = load double*, double** %26
%984 = load i32*, i32** %16
%985 = load i32, i32* %984
%986 = mul nsw i32 %985, 3
%987 = load i32, i32* %35
%988 = add nsw i32 %986, %987
%989 = sext i32 %988 to i64
%990 = getelementptr inbounds double, double* %983, i64 %989
store double %982, double* %990
br label %1005
991: ; preds = %959
%992 = load double, double* %37
%993 = load i32*, i32** %16
%994 = load i32, i32* %993
%995 = sitofp i32 %994 to double
%996 = fdiv double %992, %995
%997 = load double*, double** %26
%998 = load i32*, i32** %16
%999 = load i32, i32* %998
%1000 = mul nsw i32 %999, 3
%1001 = load i32, i32* %35
%1002 = add nsw i32 %1000, %1001
%1003 = sext i32 %1002 to i64
%1004 = getelementptr inbounds double, double* %997, i64 %1003
store double %996, double* %1004
br label %1005
1005: ; preds = %991, %970
br label %1006
1006: ; preds = %1005
%1007 = load i32, i32* %35
%1008 = add nsw i32 %1007, 1
store i32 %1008, i32* %35
br label %955
1009: ; preds = %955
br label %1010
1010: ; preds = %1009
%1011 = load i32, i32* %34
%1012 = add nsw i32 %1011, 1
store i32 %1012, i32* %34
br label %852
1013: ; preds = %852
%1014 = load i32*, i32** %16
%1015 = load i32*, i32** %17
%1016 = load i32*, i32** %18
%1017 = getelementptr inbounds i32, i32* %1016, i64 1
%1018 = load i32*, i32** %19
%1019 = getelementptr inbounds i32, i32* %1018, i64 1
%1020 = load double*, double** %26
%1021 = load i32*, i32** %16
%1022 = load i32, i32* %1021
%1023 = mul nsw i32 %1022, 3
%1024 = add nsw i32 %1023, 1
%1025 = sext i32 %1024 to i64
%1026 = getelementptr inbounds double, double* %1020, i64 %1025
%1027 = load i32*, i32** %22
%1028 = getelementptr inbounds i32, i32* %1027, i64 1
%1029 = load i32*, i32** %21
%1030 = load i32*, i32** %24
%1031 = getelementptr inbounds i32, i32* %1030, i64 1
%1032 = load i32*, i32** %24
%1033 = load i32*, i32** %16
%1034 = load i32, i32* %1033
%1035 = add nsw i32 %1034, 1
%1036 = sext i32 %1035 to i64
%1037 = getelementptr inbounds i32, i32* %1032, i64 %1036
%1038 = load i32*, i32** %24
%1039 = load i32*, i32** %16
%1040 = load i32, i32* %1039
%1041 = shl i32 %1040, 1
%1042 = add nsw i32 %1041, 1
%1043 = sext i32 %1042 to i64
%1044 = getelementptr inbounds i32, i32* %1038, i64 %1043
%1045 = load i32*, i32** %24
%1046 = load i32*, i32** %16
%1047 = load i32, i32* %1046
%1048 = mul nsw i32 %1047, 3
%1049 = add nsw i32 %1048, 1
%1050 = sext i32 %1049 to i64
%1051 = getelementptr inbounds i32, i32* %1045, i64 %1050
%1052 = load i32*, i32** %24
%1053 = load i32*, i32** %16
%1054 = load i32, i32* %1053
%1055 = shl i32 %1054, 2
%1056 = add nsw i32 %1055, 1
%1057 = sext i32 %1056 to i64
%1058 = getelementptr inbounds i32, i32* %1052, i64 %1057
%1059 = load double*, double** %26
%1060 = getelementptr inbounds double, double* %1059, i64 1
%1061 = load double*, double** %26
%1062 = load i32*, i32** %16
%1063 = load i32, i32* %1062
%1064 = add nsw i32 %1063, 1
%1065 = sext i32 %1064 to i64
%1066 = getelementptr inbounds double, double* %1061, i64 %1065
%1067 = call i32 @mc64wd_(i32* %1014, i32* %1015, i32* %1017, i32* %1019, double* %1026, i32* %1028, i32* %1029, i32* %1031, i32* %1037, i32* %1044, i32* %1051, i32* %1058, double* %1060, double* %1066)
%1068 = load i32*, i32** %21
%1069 = load i32, i32* %1068
%1070 = load i32*, i32** %16
%1071 = load i32, i32* %1070
%1072 = icmp eq i32 %1069, %1071
br i1 %1072, label %1073, label %1124
1073: ; preds = %1013
%1074 = load i32*, i32** %16
%1075 = load i32, i32* %1074
store i32 %1075, i32* %29
store i32 1, i32* %34
br label %1076
1076: ; preds = %1120, %1073
%1077 = load i32, i32* %34
%1078 = load i32, i32* %29
%1079 = icmp sle i32 %1077, %1078
br i1 %1079, label %1080, label %1123
1080: ; preds = %1076
%1081 = load double*, double** %26
%1082 = load i32*, i32** %16
%1083 = load i32, i32* %1082
%1084 = shl i32 %1083, 1
%1085 = load i32, i32* %34
%1086 = add nsw i32 %1084, %1085
%1087 = sext i32 %1086 to i64
%1088 = getelementptr inbounds double, double* %1081, i64 %1087
%1089 = load double, double* %1088
%1090 = fcmp une double %1089, 0.000000e+00
br i1 %1090, label %1091, label %1111
1091: ; preds = %1080
%1092 = load double*, double** %26
%1093 = load i32*, i32** %16
%1094 = load i32, i32* %1093
%1095 = shl i32 %1094, 1
%1096 = load i32, i32* %34
%1097 = add nsw i32 %1095, %1096
%1098 = sext i32 %1097 to i64
%1099 = getelementptr inbounds double, double* %1092, i64 %1098
%1100 = load double, double* %1099
%1101 = call double @log(double %1100)
%1102 = load double*, double** %26
%1103 = load i32*, i32** %16
%1104 = load i32, i32* %1103
%1105 = load i32, i32* %34
%1106 = add nsw i32 %1104, %1105
%1107 = sext i32 %1106 to i64
%1108 = getelementptr inbounds double, double* %1102, i64 %1107
%1109 = load double, double* %1108
%1110 = fsub double %1109, %1101
store double %1110, double* %1108
br label %1119
1111: ; preds = %1080
%1112 = load double*, double** %26
%1113 = load i32*, i32** %16
%1114 = load i32, i32* %1113
%1115 = load i32, i32* %34
%1116 = add nsw i32 %1114, %1115
%1117 = sext i32 %1116 to i64
%1118 = getelementptr inbounds double, double* %1112, i64 %1117
store double 0.000000e+00, double* %1118
br label %1119
1119: ; preds = %1111, %1091
br label %1120
1120: ; preds = %1119
%1121 = load i32, i32* %34
%1122 = add nsw i32 %1121, 1
store i32 %1122, i32* %34
br label %1076
1123: ; preds = %1076
br label %1124
1124: ; preds = %1123, %1013
%1125 = load double, double* %37
%1126 = call double @log(double %1125)
%1127 = fmul double %1126, 5.000000e-01
store double %1127, double* %36
%1128 = load i32*, i32** %16
%1129 = load i32, i32* %1128
store i32 %1129, i32* %29
store i32 1, i32* %34
br label %1130
1130: ; preds = %1158, %1124
%1131 = load i32, i32* %34
%1132 = load i32, i32* %29
%1133 = icmp sle i32 %1131, %1132
br i1 %1133, label %1134, label %1161
1134: ; preds = %1130
%1135 = load double*, double** %26
%1136 = load i32, i32* %34
%1137 = sext i32 %1136 to i64
%1138 = getelementptr inbounds double, double* %1135, i64 %1137
%1139 = load double, double* %1138
%1140 = load double, double* %36
%1141 = fcmp olt double %1139, %1140
br i1 %1141, label %1142, label %1154
1142: ; preds = %1134
%1143 = load double*, double** %26
%1144 = load i32*, i32** %16
%1145 = load i32, i32* %1144
%1146 = load i32, i32* %34
%1147 = add nsw i32 %1145, %1146
%1148 = sext i32 %1147 to i64
%1149 = getelementptr inbounds double, double* %1143, i64 %1148
%1150 = load double, double* %1149
%1151 = load double, double* %36
%1152 = fcmp olt double %1150, %1151
br i1 %1152, label %1153, label %1154
1153: ; preds = %1142
br label %1157
1154: ; preds = %1142, %1134
%1155 = load i32*, i32** %28
%1156 = getelementptr inbounds i32, i32* %1155, i64 1
store i32 2, i32* %1156
br label %1163
1157: ; preds = %1153
br label %1158
1158: ; preds = %1157
%1159 = load i32, i32* %34
%1160 = add nsw i32 %1159, 1
store i32 %1160, i32* %34
br label %1130
1161: ; preds = %1130
br label %1162
1162: ; preds = %1161, %845
br label %1163
1163: ; preds = %1162, %1154, %790, %590, %511, %505
%1164 = load i32*, i32** %28
%1165 = getelementptr inbounds i32, i32* %1164, i64 1
%1166 = load i32, i32* %1165
%1167 = icmp eq i32 %1166, 0
br i1 %1167, label %1168, label %1187
1168: ; preds = %1163
%1169 = load i32*, i32** %21
%1170 = load i32, i32* %1169
%1171 = load i32*, i32** %16
%1172 = load i32, i32* %1171
%1173 = icmp slt i32 %1170, %1172
br i1 %1173, label %1174, label %1187
1174: ; preds = %1168
%1175 = load i32*, i32** %28
%1176 = getelementptr inbounds i32, i32* %1175, i64 1
store i32 1, i32* %1176
%1177 = load i32*, i32** %27
%1178 = getelementptr inbounds i32, i32* %1177, i64 2
%1179 = load i32, i32* %1178
%1180 = icmp sge i32 %1179, 0
br i1 %1180, label %1181, label %1186
1181: ; preds = %1174
%1182 = load i32*, i32** %28
%1183 = getelementptr inbounds i32, i32* %1182, i64 1
%1184 = load i32, i32* %1183
%1185 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.19, i64 0, i64 0), i32 %1184, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.20, i64 0, i64 0))
br label %1186
1186: ; preds = %1181, %1174
br label %1187
1187: ; preds = %1186, %1168, %1163
%1188 = load i32*, i32** %28
%1189 = getelementptr inbounds i32, i32* %1188, i64 1
%1190 = load i32, i32* %1189
%1191 = icmp eq i32 %1190, 2
br i1 %1191, label %1192, label %1203
1192: ; preds = %1187
%1193 = load i32*, i32** %27
%1194 = getelementptr inbounds i32, i32* %1193, i64 2
%1195 = load i32, i32* %1194
%1196 = icmp sge i32 %1195, 0
br i1 %1196, label %1197, label %1202
1197: ; preds = %1192
%1198 = load i32*, i32** %28
%1199 = getelementptr inbounds i32, i32* %1198, i64 1
%1200 = load i32, i32* %1199
%1201 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.21, i64 0, i64 0), i32 %1200, i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.22, i64 0, i64 0))
br label %1202
1202: ; preds = %1197, %1192
br label %1203
1203: ; preds = %1202, %1187
%1204 = load i32*, i32** %27
%1205 = getelementptr inbounds i32, i32* %1204, i64 3
%1206 = load i32, i32* %1205
%1207 = icmp sge i32 %1206, 0
br i1 %1207, label %1208, label %1297
1208: ; preds = %1203
%1209 = load i32*, i32** %28
%1210 = getelementptr inbounds i32, i32* %1209, i64 1
%1211 = load i32, i32* %1210
%1212 = load i32*, i32** %28
%1213 = getelementptr inbounds i32, i32* %1212, i64 2
%1214 = load i32, i32* %1213
%1215 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.23, i64 0, i64 0), i32 %1211, i32 %1214)
%1216 = load i32*, i32** %21
%1217 = load i32, i32* %1216
%1218 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.24, i64 0, i64 0), i32 %1217)
%1219 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.25, i64 0, i64 0))
store i32 1, i32* %34
br label %1220
1220: ; preds = %1238, %1208
%1221 = load i32, i32* %34
%1222 = load i32*, i32** %16
%1223 = load i32, i32* %1222
%1224 = icmp sle i32 %1221, %1223
br i1 %1224, label %1225, label %1241
1225: ; preds = %1220
%1226 = load i32*, i32** %22
%1227 = load i32, i32* %34
%1228 = sext i32 %1227 to i64
%1229 = getelementptr inbounds i32, i32* %1226, i64 %1228
%1230 = load i32, i32* %1229
%1231 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.13, i64 0, i64 0), i32 %1230)
%1232 = load i32, i32* %34
%1233 = srem i32 %1232, 8
%1234 = icmp eq i32 %1233, 0
br i1 %1234, label %1235, label %1237
1235: ; preds = %1225
%1236 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0))
br label %1237
1237: ; preds = %1235, %1225
br label %1238
1238: ; preds = %1237
%1239 = load i32, i32* %34
%1240 = add nsw i32 %1239, 1
store i32 %1240, i32* %34
br label %1220
1241: ; preds = %1220
%1242 = load i32*, i32** %15
%1243 = load i32, i32* %1242
%1244 = icmp eq i32 %1243, 5
br i1 %1244, label %1245, label %1296
1245: ; preds = %1241
%1246 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.26, i64 0, i64 0))
store i32 1, i32* %34
br label %1247
1247: ; preds = %1265, %1245
%1248 = load i32, i32* %34
%1249 = load i32*, i32** %16
%1250 = load i32, i32* %1249
%1251 = icmp sle i32 %1248, %1250
br i1 %1251, label %1252, label %1268
1252: ; preds = %1247
%1253 = load double*, double** %26
%1254 = load i32, i32* %34
%1255 = sext i32 %1254 to i64
%1256 = getelementptr inbounds double, double* %1253, i64 %1255
%1257 = load double, double* %1256
%1258 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.27, i64 0, i64 0), double %1257)
%1259 = load i32, i32* %34
%1260 = srem i32 %1259, 5
%1261 = icmp eq i32 %1260, 0
br i1 %1261, label %1262, label %1264
1262: ; preds = %1252
%1263 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0))
br label %1264
1264: ; preds = %1262, %1252
br label %1265
1265: ; preds = %1264
%1266 = load i32, i32* %34
%1267 = add nsw i32 %1266, 1
store i32 %1267, i32* %34
br label %1247
1268: ; preds = %1247
%1269 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.28, i64 0, i64 0))
store i32 1, i32* %34
br label %1270
1270: ; preds = %1291, %1268
%1271 = load i32, i32* %34
%1272 = load i32*, i32** %16
%1273 = load i32, i32* %1272
%1274 = icmp sle i32 %1271, %1273
br i1 %1274, label %1275, label %1294
1275: ; preds = %1270
%1276 = load double*, double** %26
%1277 = load i32*, i32** %16
%1278 = load i32, i32* %1277
%1279 = load i32, i32* %34
%1280 = add nsw i32 %1278, %1279
%1281 = sext i32 %1280 to i64
%1282 = getelementptr inbounds double, double* %1276, i64 %1281
%1283 = load double, double* %1282
%1284 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.27, i64 0, i64 0), double %1283)
%1285 = load i32, i32* %34
%1286 = srem i32 %1285, 5
%1287 = icmp eq i32 %1286, 0
br i1 %1287, label %1288, label %1290
1288: ; preds = %1275
%1289 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0))
br label %1290
1290: ; preds = %1288, %1275
br label %1291
1291: ; preds = %1290
%1292 = load i32, i32* %34
%1293 = add nsw i32 %1292, 1
store i32 %1293, i32* %34
br label %1270
1294: ; preds = %1270
%1295 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0))
br label %1296
1296: ; preds = %1294, %1241
br label %1297
1297: ; preds = %1296, %1203
br label %1298
1298: ; preds = %1297, %356, %330, %254, %192, %127, %104, %81
ret i32 0
}

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