void pred_(double *y, double *x_, double *new_x, int *size_info,
           double *residual_scale, double *weights, double *robust,
           double *span, int *degree, int *normalize, int *parametric,
           int *drop_square, char **surface, double *cell, char **family,
           int *parameter, int *a, double *xi, double *vert, double *vval,
           double *divisor, int *se, double *fit, double *se_fit) {
  double *x, *x_tmp, *x_evaluate, *L, new_cell, tmp, *fit_tmp, *temp;
  int N, D, M, sum_drop_sqr = 0, sum_parametric = 0, nonparametric = 0,
               *order_parametric, *order_drop_sqr;
  int i, j, k, p;
  int gaussian_family = !strcmp(*family, "gaussian");
  int direct_surface = !strcmp(*surface, "direct");
  D = size_info[0];
  N = size_info[1];
  M = size_info[2];
  x = safe_malloc(N * D * sizeof(double), 31);
  x_tmp = safe_malloc(N * D * sizeof(double), 32);
  x_evaluate = safe_malloc(M * D * sizeof(double), 33);
  L = safe_malloc(N * M * sizeof(double), 34);
  order_parametric = safe_malloc(D * sizeof(int), 35);
  order_drop_sqr = safe_malloc(D * sizeof(int), 36);
  temp = safe_malloc(N * D * sizeof(double), 37);
  for (i = 0; i < (N * D); i++)
    x_tmp[i] = x_[i];
  for (i = 0; i < D; i++) {
    k = i * M;
    for (j = 0; j < M; j++) {
      p = k + j;
      new_x[p] = new_x[p] / divisor[i];
    }
  }
  if (direct_surface || se) {
    for (i = 0; i < D; i++) {
      k = i * N;
      for (j = 0; j < N; j++) {
        p = k + j;
        x_tmp[p] = x_[p] / divisor[i];
      }
    }
  }
  j = D - 1;
  for (i = 0; i < D; i++) {
    sum_drop_sqr = sum_drop_sqr + drop_square[i];
    sum_parametric = sum_parametric + parametric[i];
    if (parametric[i])
      order_parametric[j--] = i;
    else
      order_parametric[nonparametric++] = i;
  }
  for (i = 0; i < D; i++) {
    order_drop_sqr[i] = 2 - drop_square[order_parametric[i]];
    k = i * M;
    p = order_parametric[i] * M;
    for (j = 0; j < M; j++)
      x_evaluate[k + j] = new_x[p + j];
    k = i * N;
    p = order_parametric[i] * N;
    for (j = 0; j < N; j++)
      x[k + j] = x_tmp[p + j];
  }
  for (i = 0; i < N; i++)
    robust[i] = weights[i] * robust[i];
  if (direct_surface) {
    if (*se) {
      loess_dfitse(y, x, x_evaluate, weights, robust, &gaussian_family, span,
                   degree, &nonparametric, order_drop_sqr, &sum_drop_sqr, &D,
                   &N, &M, fit, L);
    } else {
      loess_dfit(y, x, x_evaluate, robust, span, degree, &nonparametric,
                 order_drop_sqr, &sum_drop_sqr, &D, &N, &M, fit);
    }
  } else {
    loess_ifit(parameter, a, xi, vert, vval, &M, x_evaluate, fit);
    if (*se) {
      new_cell = (*span) * (*cell);
      fit_tmp = safe_malloc(M * sizeof(double), 97);
      loess_ise(y, x, x_evaluate, weights, span, degree, &nonparametric,
                order_drop_sqr, &sum_drop_sqr, &new_cell, &D, &N, &M, fit_tmp,
                L);
      free(fit_tmp);
    }
  }
  if (*se) {
    for (i = 0; i < N; i++) {
      k = i * M;
      for (j = 0; j < M; j++) {
        p = k + j;
        L[p] = L[p] / weights[i];
        L[p] = L[p] * L[p];
      }
    }
    for (i = 0; i < M; i++) {
      tmp = 0;
      for (j = 0; j < N; j++)
        tmp = tmp + L[i + j * M];
      se_fit[i] = (*residual_scale) * sqrt(tmp);
    }
  }
  free(x);
  free(x_tmp);
  free(x_evaluate);
  free(L);
  free(order_parametric);
  free(order_drop_sqr);
  free(temp);
}


x86 assembly (clang, -O0):
<pred_>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    0x98(%rbp),%rax
mov    0x90(%rbp),%rax
mov    0x88(%rbp),%rax
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x30(%rbp)
mov    %rsi,-0x38(%rbp)
mov    %rdx,-0x40(%rbp)
mov    %rcx,-0x48(%rbp)
mov    %r8,-0x50(%rbp)
mov    %r9,-0x58(%rbp)
movl   $0x0,-0xa8(%rbp)
movl   $0x0,-0xac(%rbp)
movl   $0x0,-0xb0(%rbp)
mov    0x50(%rbp),%rax
mov    (%rax),%rdi
lea    0xdd4(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xd4(%rbp)
mov    0x40(%rbp),%rax
mov    (%rax),%rdi
lea    0xdb7(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xd8(%rbp)
mov    -0x48(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0xa0(%rbp)
mov    -0x48(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x48(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x9c(%rbp),%eax
imul   -0xa0(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
mov    $0x1f,%esi
mov    $0x0,%al
call   1050 <safe_malloc@plt>
cltq
mov    %rax,-0x60(%rbp)
mov    -0x9c(%rbp),%eax
imul   -0xa0(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
mov    $0x20,%esi
mov    $0x0,%al
call   1050 <safe_malloc@plt>
cltq
mov    %rax,-0x68(%rbp)
mov    -0xa4(%rbp),%eax
imul   -0xa0(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
mov    $0x21,%esi
mov    $0x0,%al
call   1050 <safe_malloc@plt>
cltq
mov    %rax,-0x70(%rbp)
mov    -0x9c(%rbp),%eax
imul   -0xa4(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
mov    $0x22,%esi
mov    $0x0,%al
call   1050 <safe_malloc@plt>
cltq
mov    %rax,-0x78(%rbp)
movslq -0xa0(%rbp),%rdi
shl    $0x2,%rdi
mov    $0x23,%esi
mov    $0x0,%al
call   1050 <safe_malloc@plt>
cltq
mov    %rax,-0xb8(%rbp)
movslq -0xa0(%rbp),%rdi
shl    $0x2,%rdi
mov    $0x24,%esi
mov    $0x0,%al
call   1050 <safe_malloc@plt>
cltq
mov    %rax,-0xc0(%rbp)
mov    -0x9c(%rbp),%eax
imul   -0xa0(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
mov    $0x25,%esi
mov    $0x0,%al
call   1050 <safe_malloc@plt>
cltq
mov    %rax,-0x98(%rbp)
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    -0x9c(%rbp),%ecx
imul   -0xa0(%rbp),%ecx
cmp    %ecx,%eax
jge    13ea <pred_+0x26a>
mov    -0x38(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    139b <pred_+0x21b>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    14a7 <pred_+0x327>
mov    -0xc4(%rbp),%eax
imul   -0xa4(%rbp),%eax
mov    %eax,-0xcc(%rbp)
movl   $0x0,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    -0xa4(%rbp),%eax
jge    148e <pred_+0x30e>
mov    -0xcc(%rbp),%eax
add    -0xc8(%rbp),%eax
mov    %eax,-0xd0(%rbp)
mov    -0x40(%rbp),%rax
movslq -0xd0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
movslq -0xc4(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0xd0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    1423 <pred_+0x2a3>
jmp    1493 <pred_+0x313>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    13f4 <pred_+0x274>
cmpl   $0x0,-0xd8(%rbp)
jne    14c2 <pred_+0x342>
cmpq   $0x0,0x88(%rbp)
je     1584 <pred_+0x404>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    157f <pred_+0x3ff>
mov    -0xc4(%rbp),%eax
imul   -0x9c(%rbp),%eax
mov    %eax,-0xcc(%rbp)
movl   $0x0,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    1566 <pred_+0x3e6>
mov    -0xcc(%rbp),%eax
add    -0xc8(%rbp),%eax
mov    %eax,-0xd0(%rbp)
mov    -0x38(%rbp),%rax
movslq -0xd0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
movslq -0xc4(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0xd0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    14fb <pred_+0x37b>
jmp    156b <pred_+0x3eb>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    14cc <pred_+0x34c>
jmp    1584 <pred_+0x404>
mov    -0xa0(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xc8(%rbp)
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    165e <pred_+0x4de>
mov    -0xa8(%rbp),%eax
mov    0x38(%rbp),%rcx
movslq -0xc4(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xac(%rbp),%eax
mov    0x30(%rbp),%rcx
movslq -0xc4(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0xac(%rbp)
mov    0x30(%rbp),%rax
movslq -0xc4(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1621 <pred_+0x4a1>
mov    -0xc4(%rbp),%edx
mov    -0xb8(%rbp),%rax
mov    -0xc8(%rbp),%ecx
mov    %ecx,%esi
add    $0xffffffff,%esi
mov    %esi,-0xc8(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1645 <pred_+0x4c5>
mov    -0xc4(%rbp),%edx
mov    -0xb8(%rbp),%rax
mov    -0xb0(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0xb0(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    164a <pred_+0x4ca>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    159d <pred_+0x41d>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    17e4 <pred_+0x664>
mov    0x38(%rbp),%rax
mov    -0xb8(%rbp),%rcx
movslq -0xc4(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    $0x2,%edx
sub    (%rax,%rcx,4),%edx
mov    -0xc0(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xc4(%rbp),%eax
imul   -0xa4(%rbp),%eax
mov    %eax,-0xcc(%rbp)
mov    -0xb8(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
imul   -0xa4(%rbp),%eax
mov    %eax,-0xd0(%rbp)
movl   $0x0,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    -0xa4(%rbp),%eax
jge    173a <pred_+0x5ba>
mov    -0x40(%rbp),%rax
mov    -0xd0(%rbp),%ecx
add    -0xc8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xc8(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    16e4 <pred_+0x564>
mov    -0xc4(%rbp),%eax
imul   -0x9c(%rbp),%eax
mov    %eax,-0xcc(%rbp)
mov    -0xb8(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
imul   -0x9c(%rbp),%eax
mov    %eax,-0xd0(%rbp)
movl   $0x0,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    17cb <pred_+0x64b>
mov    -0x68(%rbp),%rax
mov    -0xd0(%rbp),%ecx
add    -0xc8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xc8(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    1775 <pred_+0x5f5>
jmp    17d0 <pred_+0x650>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1668 <pred_+0x4e8>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    1844 <pred_+0x6c4>
mov    -0x58(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    17ee <pred_+0x66e>
cmpl   $0x0,-0xd8(%rbp)
je     1989 <pred_+0x809>
mov    0x88(%rbp),%rax
cmpl   $0x0,(%rax)
je     1912 <pred_+0x792>
mov    -0x30(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x70(%rbp),%rdx
mov    -0x58(%rbp),%rcx
mov    0x10(%rbp),%r8
mov    0x18(%rbp),%rax
mov    0x20(%rbp),%r9
mov    %r9,-0xe8(%rbp)
mov    -0xc0(%rbp),%r12
mov    0x90(%rbp),%r10
mov    -0x78(%rbp),%r9
mov    %r9,-0xe0(%rbp)
lea    -0xd4(%rbp),%r9
lea    -0xb0(%rbp),%r13
lea    -0xa8(%rbp),%r15
lea    -0xa0(%rbp),%r14
lea    -0x9c(%rbp),%rbx
lea    -0xa4(%rbp),%r11
mov    %rax,(%rsp)
mov    -0xe8(%rbp),%rax
mov    %rax,0x8(%rsp)
mov    -0xe0(%rbp),%rax
mov    %r13,0x10(%rsp)
mov    %r12,0x18(%rsp)
mov    %r15,0x20(%rsp)
mov    %r14,0x28(%rsp)
mov    %rbx,0x30(%rsp)
mov    %r11,0x38(%rsp)
mov    %r10,0x40(%rsp)
mov    %rax,0x48(%rsp)
mov    $0x0,%al
call   1080 <loess_dfitse@plt>
jmp    1984 <pred_+0x804>
mov    -0x30(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x70(%rbp),%rdx
mov    0x10(%rbp),%rcx
mov    0x18(%rbp),%r8
mov    0x20(%rbp),%r9
mov    -0xc0(%rbp),%r15
mov    0x90(%rbp),%rax
lea    -0xb0(%rbp),%r12
lea    -0xa8(%rbp),%r14
lea    -0xa0(%rbp),%rbx
lea    -0x9c(%rbp),%r11
lea    -0xa4(%rbp),%r10
mov    %r12,(%rsp)
mov    %r15,0x8(%rsp)
mov    %r14,0x10(%rsp)
mov    %rbx,0x18(%rsp)
mov    %r11,0x20(%rsp)
mov    %r10,0x28(%rsp)
mov    %rax,0x30(%rsp)
mov    $0x0,%al
call   10a0 <loess_dfit@plt>
jmp    1aa7 <pred_+0x927>
mov    0x58(%rbp),%rdi
mov    0x60(%rbp),%rsi
mov    0x68(%rbp),%rdx
mov    0x70(%rbp),%rcx
mov    0x78(%rbp),%r8
mov    -0x70(%rbp),%r10
mov    0x90(%rbp),%rax
lea    -0xa4(%rbp),%r9
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1040 <loess_ifit@plt>
mov    0x88(%rbp),%rax
cmpl   $0x0,(%rax)
je     1aa2 <pred_+0x922>
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x48(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
movslq -0xa4(%rbp),%rdi
shl    $0x3,%rdi
mov    $0x61,%esi
mov    $0x0,%al
call   1050 <safe_malloc@plt>
cltq
mov    %rax,-0x90(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x70(%rbp),%rdx
mov    -0x58(%rbp),%rcx
mov    0x18(%rbp),%r8
mov    0x20(%rbp),%r9
mov    -0xc0(%rbp),%r13
mov    -0x90(%rbp),%r10
mov    -0x78(%rbp),%rax
mov    %rax,-0xf0(%rbp)
lea    -0xb0(%rbp),%rax
lea    -0xa8(%rbp),%r12
lea    -0x80(%rbp),%r15
lea    -0xa0(%rbp),%r14
lea    -0x9c(%rbp),%rbx
lea    -0xa4(%rbp),%r11
mov    %rax,(%rsp)
mov    -0xf0(%rbp),%rax
mov    %r13,0x8(%rsp)
mov    %r12,0x10(%rsp)
mov    %r15,0x18(%rsp)
mov    %r14,0x20(%rsp)
mov    %rbx,0x28(%rsp)
mov    %r11,0x30(%rsp)
mov    %r10,0x38(%rsp)
mov    %rax,0x40(%rsp)
mov    $0x0,%al
call   1060 <loess_ise@plt>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
jmp    1aa7 <pred_+0x927>
mov    0x88(%rbp),%rax
cmpl   $0x0,(%rax)
je     1c81 <pred_+0xb01>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    1ba1 <pred_+0xa21>
mov    -0xc4(%rbp),%eax
imul   -0xa4(%rbp),%eax
mov    %eax,-0xcc(%rbp)
movl   $0x0,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    -0xa4(%rbp),%eax
jge    1b88 <pred_+0xa08>
mov    -0xcc(%rbp),%eax
add    -0xc8(%rbp),%eax
mov    %eax,-0xd0(%rbp)
mov    -0x78(%rbp),%rax
movslq -0xd0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0xc4(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
movslq -0xd0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
movslq -0xd0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
movslq -0xd0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
movslq -0xd0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    1af0 <pred_+0x970>
jmp    1b8d <pred_+0xa0d>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1ac1 <pred_+0x941>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0xa4(%rbp),%eax
jge    1c7c <pred_+0xafc>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    1c29 <pred_+0xaa9>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x78(%rbp),%rax
mov    -0xc4(%rbp),%ecx
mov    -0xc8(%rbp),%edx
imul   -0xa4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    1bd2 <pred_+0xa52>
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
call   1090 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0xf8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    0x98(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1bab <pred_+0xa2b>
jmp    1c81 <pred_+0xb01>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<pred_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
mov    %r9,0x40(%rsp)
mov    %r8,0x88(%rsp)
mov    %rcx,%r15
mov    %rdx,0x50(%rsp)
mov    %rsi,%rbx
mov    %rdi,0x80(%rsp)
mov    0x130(%rsp),%rbp
mov    0x140(%rsp),%rax
movl   $0x0,0x18(%rsp)
movl   $0x0,0x14(%rsp)
mov    (%rax),%rdi
lea    0x1e25(%rip),%rsi
call   1070 <strcmp@plt>
xor    %ecx,%ecx
test   %eax,%eax
sete   %cl
mov    %ecx,0xac(%rsp)
mov    0x0(%rbp),%rdi
lea    0x1e10(%rip),%rsi
call   1070 <strcmp@plt>
mov    %eax,0x7c(%rsp)
movslq (%r15),%r12
mov    %r12d,%eax
mov    %rax,0x8(%rsp)
mov    %r12d,0x1c(%rsp)
movslq 0x4(%r15),%r14
mov    %r14d,0x4(%rsp)
movslq 0x8(%r15),%r13
mov    %r13d,(%rsp)
mov    %r14d,%eax
imul   %r12d,%eax
mov    %eax,0x38(%rsp)
cltq
mov    %rax,0x28(%rsp)
lea    0x0(,%rax,8),%rbp
mov    %rbp,%rdi
mov    $0x1f,%esi
xor    %eax,%eax
call   1050 <safe_malloc@plt>
mov    %eax,0x48(%rsp)
mov    %rbp,%rdi
mov    $0x20,%esi
xor    %eax,%eax
call   1050 <safe_malloc@plt>
movslq %eax,%r15
mov    %r12d,%eax
imul   %r13d,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
mov    $0x21,%esi
xor    %eax,%eax
call   1050 <safe_malloc@plt>
mov    %eax,0x30(%rsp)
mov    %r13d,%eax
mov    %r14,0x58(%rsp)
imul   %r14d,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
mov    $0x22,%esi
xor    %eax,%eax
call   1050 <safe_malloc@plt>
mov    %eax,0xa4(%rsp)
shl    $0x2,%r12
mov    %r12,%rdi
mov    $0x23,%esi
xor    %eax,%eax
call   1050 <safe_malloc@plt>
mov    %eax,0x20(%rsp)
mov    %r12,%rdi
mov    $0x24,%esi
xor    %eax,%eax
call   1050 <safe_malloc@plt>
mov    %eax,%r12d
mov    %rbp,%rdi
mov    $0x25,%esi
xor    %eax,%eax
call   1050 <safe_malloc@plt>
mov    %eax,0xa8(%rsp)
cmpl   $0x0,0x28(%rsp)
jle    1478 <pred_+0x2f8>
mov    0x38(%rsp),%r14d
mov    %r14d,%eax
cmp    $0x4,%r14d
jb     1318 <pred_+0x198>
lea    (%rbx,%rax,8),%rcx
cmp    %rcx,%r15
jae    1390 <pred_+0x210>
lea    (%r15,%rax,8),%rcx
cmp    %rbx,%rcx
jbe    1390 <pred_+0x210>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     1345 <pred_+0x1c5>
nopl   0x0(%rax)
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1330 <pred_+0x1b0>
cmp    $0x3,%rdx
jb     1478 <pred_+0x2f8>
nop
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r15,%rcx,8)
movsd  0x10(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x10(%r15,%rcx,8)
movsd  0x18(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x18(%r15,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1350 <pred_+0x1d0>
jmp    1478 <pred_+0x2f8>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0xc,%rdi
jae    13b6 <pred_+0x236>
xor    %edi,%edi
jmp    1434 <pred_+0x2b4>
movabs $0x7ffffffffffffffe,%rdi
ff ff 7f
add    $0xfffffffffffffffe,%rdi
and    %rdi,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movups (%rbx,%rdi,8),%xmm0
movups 0x10(%rbx,%rdi,8),%xmm1
movups %xmm0,(%r15,%rdi,8)
movups %xmm1,0x10(%r15,%rdi,8)
movups 0x20(%rbx,%rdi,8),%xmm0
movups 0x30(%rbx,%rdi,8),%xmm1
movups %xmm0,0x20(%r15,%rdi,8)
movups %xmm1,0x30(%r15,%rdi,8)
movups 0x40(%rbx,%rdi,8),%xmm0
movups 0x50(%rbx,%rdi,8),%xmm1
movups %xmm0,0x40(%r15,%rdi,8)
movups %xmm1,0x50(%r15,%rdi,8)
movupd 0x60(%rbx,%rdi,8),%xmm0
movupd 0x70(%rbx,%rdi,8),%xmm1
movupd %xmm0,0x60(%r15,%rdi,8)
movupd %xmm1,0x70(%r15,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    13d0 <pred_+0x250>
test   %rdx,%rdx
je     146f <pred_+0x2ef>
lea    (%r15,%rdi,8),%rsi
add    $0x10,%rsi
lea    (%rbx,%rdi,8),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nop
movupd -0x10(%rdi,%rbp,1),%xmm0
movupd (%rdi,%rbp,1),%xmm1
movupd %xmm0,-0x10(%rsi,%rbp,1)
movupd %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1450 <pred_+0x2d0>
cmp    %rax,%rcx
jne    131a <pred_+0x19a>
movslq 0x48(%rsp),%rax
mov    %rax,0x28(%rsp)
movslq 0x30(%rsp),%rax
mov    %rax,0x30(%rsp)
movslq 0x20(%rsp),%rax
mov    %rax,0x90(%rsp)
movslq %r12d,%rax
mov    %rax,0x48(%rsp)
mov    0x8(%rsp),%r11
test   %r11d,%r11d
mov    %r15,0x98(%rsp)
mov    0x50(%rsp),%r12
jle    1d5b <pred_+0xbdb>
mov    %rbx,0x20(%rsp)
mov    0x58(%rsp),%edx
mov    %r13d,%eax
mov    0x170(%rsp),%rsi
mov    %eax,%ecx
and    $0xfffffffe,%ecx
mov    %rcx,0x38(%rsp)
add    $0xfffffffffffffffe,%rcx
mov    %rcx,0x70(%rsp)
mov    %rcx,%rdi
shr    %rdi
add    $0x1,%rdi
mov    %rdi,%rcx
mov    %rdi,0x68(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x60(%rsp)
mov    %rax,%r14
neg    %r14
lea    0x10(%r12),%rdi
lea    0x0(,%r13,8),%rcx
xor    %r8d,%r8d
mov    %r12,%r9
jmp    1533 <pred_+0x3b3>
nopl   0x0(%rax)
add    $0x1,%r8
add    %rcx,%rdi
add    %rcx,%r9
cmp    %r11,%r8
je     1667 <pred_+0x4e7>
test   %r13d,%r13d
jle    1520 <pred_+0x3a0>
mov    %r8,%r10
imul   %r13,%r10
cmp    $0x1,%eax
je     1566 <pred_+0x3e6>
lea    (%r12,%r10,8),%rbp
lea    (%rsi,%r8,8),%rbx
add    $0x8,%rbx
cmp    %rbx,%rbp
jae    15d4 <pred_+0x454>
lea    (%r10,%rax,1),%rbp
lea    (%r12,%rbp,8),%rbp
lea    (%rsi,%r8,8),%rbx
cmp    %rbp,%rbx
jae    15d4 <pred_+0x454>
xor    %ebp,%ebp
mov    %rbp,%rbx
test   $0x1,%al
je     158b <pred_+0x40b>
add    %rbp,%r10
movsd  (%r12,%r10,8),%xmm0
divsd  (%rsi,%r8,8),%xmm0
movsd  %xmm0,(%r12,%r10,8)
mov    %rbp,%rbx
or     $0x1,%rbx
not    %rbp
cmp    %r14,%rbp
je     1520 <pred_+0x3a0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r9,%rbx,8),%xmm0
divsd  (%rsi,%r8,8),%xmm0
movsd  0x8(%r9,%rbx,8),%xmm1
movsd  %xmm0,(%r9,%rbx,8)
divsd  (%rsi,%r8,8),%xmm1
movsd  %xmm1,0x8(%r9,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%rax
jne    15a0 <pred_+0x420>
jmp    1520 <pred_+0x3a0>
cmpq   $0x0,0x70(%rsp)
je     165b <pred_+0x4db>
movsd  (%rsi,%r8,8),%xmm0
unpcklpd %xmm0,%xmm0
mov    0x60(%rsp),%rbx
xor    %r11d,%r11d
xchg   %ax,%ax
movupd -0x10(%rdi,%r11,8),%xmm1
movupd (%rdi,%r11,8),%xmm2
divpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%rdi,%r11,8)
divpd  %xmm0,%xmm2
movupd %xmm2,(%rdi,%r11,8)
add    $0x4,%r11
add    $0xfffffffffffffffe,%rbx
jne    15f0 <pred_+0x470>
testb  $0x1,0x68(%rsp)
je     1640 <pred_+0x4c0>
add    %r10,%r11
movupd (%r12,%r11,8),%xmm0
movsd  (%rsi,%r8,8),%xmm1
unpcklpd %xmm1,%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,(%r12,%r11,8)
mov    0x38(%rsp),%rbx
mov    %rbx,%rbp
cmp    %rax,%rbx
mov    0x8(%rsp),%r11
je     1520 <pred_+0x3a0>
jmp    1568 <pred_+0x3e8>
xor    %r11d,%r11d
testb  $0x1,0x68(%rsp)
jne    1623 <pred_+0x4a3>
jmp    1640 <pred_+0x4c0>
cmpl   $0x0,0x7c(%rsp)
setne  %al
cmpq   $0x0,0x178(%rsp)
sete   %cl
test   %al,%cl
mov    0x58(%rsp),%rbx
jne    18d2 <pred_+0x752>
cmpl   $0x0,0x8(%rsp)
jle    18d2 <pred_+0x752>
mov    %edx,%eax
and    $0xfffffffe,%eax
mov    %rax,0x68(%rsp)
add    $0xfffffffffffffffe,%rax
mov    %rax,0x60(%rsp)
mov    %rax,%rcx
shr    %rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0xb8(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xb0(%rsp)
mov    %rdx,%rax
neg    %rax
mov    %rax,0x70(%rsp)
lea    0x10(%r15),%rcx
lea    0x0(,%rbx,8),%r14
mov    0x20(%rsp),%rax
lea    0x10(%rax),%r9
lea    0x8(%rax),%r8
lea    0x8(%r15),%r10
xor    %r11d,%r11d
jmp    171b <pred_+0x59b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r11
add    %r14,%rcx
add    %r14,%r9
add    %r14,%r8
add    %r14,%r10
cmp    0x8(%rsp),%r11
je     18d2 <pred_+0x752>
test   %ebx,%ebx
jle    1700 <pred_+0x580>
mov    %r11,%r13
imul   %rbx,%r13
cmp    $0x1,%edx
jne    17a0 <pred_+0x620>
xor    %eax,%eax
mov    %rax,%rdi
test   $0x1,%dl
je     1756 <pred_+0x5d6>
add    %rax,%r13
mov    0x20(%rsp),%rdi
movsd  (%rdi,%r13,8),%xmm0
divsd  (%rsi,%r11,8),%xmm0
movsd  %xmm0,(%r15,%r13,8)
mov    %rax,%rdi
or     $0x1,%rdi
not    %rax
cmp    0x70(%rsp),%rax
je     1700 <pred_+0x580>
movsd  -0x8(%r8,%rdi,8),%xmm0
divsd  (%rsi,%r11,8),%xmm0
movsd  %xmm0,-0x8(%r10,%rdi,8)
movsd  (%r8,%rdi,8),%xmm0
divsd  (%rsi,%r11,8),%xmm0
movsd  %xmm0,(%r10,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rdx
jne    1760 <pred_+0x5e0>
jmp    1700 <pred_+0x580>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rdx,%r13,1),%rax
lea    (%r15,%r13,8),%rdi
lea    (%r15,%rax,8),%r12
mov    0x20(%rsp),%rbp
lea    0x0(,%r13,8),%rbx
add    %rbp,%rbx
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
lea    (%rsi,%r11,8),%rbp
lea    (%rsi,%r11,8),%r15
add    $0x8,%r15
cmp    %rax,%rdi
setb   0x38(%rsp)
cmp    %r12,%rbx
setb   %al
cmp    %r15,%rdi
setb   %bl
cmp    %r12,%rbp
setb   %dil
test   %al,0x38(%rsp)
jne    18ab <pred_+0x72b>
mov    $0x0,%eax
and    %dil,%bl
mov    0x98(%rsp),%r15
mov    0x50(%rsp),%r12
mov    0x58(%rsp),%rbx
jne    172d <pred_+0x5ad>
cmpq   $0x0,0x60(%rsp)
je     18c4 <pred_+0x744>
movsd  (%rsi,%r11,8),%xmm0
unpcklpd %xmm0,%xmm0
mov    0xb0(%rsp),%rax
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movupd -0x10(%r9,%rdi,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%rcx,%rdi,8)
movupd (%r9,%rdi,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rcx,%rdi,8)
add    $0x4,%rdi
add    $0xfffffffffffffffe,%rax
jne    1840 <pred_+0x6c0>
testb  $0x1,0xb8(%rsp)
01
je     1895 <pred_+0x715>
add    %r13,%rdi
mov    0x20(%rsp),%rax
movupd (%rax,%rdi,8),%xmm0
movsd  (%rsi,%r11,8),%xmm1
unpcklpd %xmm1,%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,(%r15,%rdi,8)
mov    0x68(%rsp),%rdi
mov    %rdi,%rax
cmp    %rdx,%rdi
je     1700 <pred_+0x580>
jmp    172d <pred_+0x5ad>
xor    %eax,%eax
mov    0x98(%rsp),%r15
mov    0x50(%rsp),%r12
mov    0x58(%rsp),%rbx
jmp    172d <pred_+0x5ad>
xor    %edi,%edi
testb  $0x1,0xb8(%rsp)
01
jne    1874 <pred_+0x6f4>
jmp    1895 <pred_+0x715>
mov    0x8(%rsp),%rax
test   %eax,%eax
mov    0x28(%rsp),%r8
mov    0x128(%rsp),%rbp
mov    0x90(%rsp),%rdi
jle    1d5b <pred_+0xbdb>
add    $0xffffffff,%eax
xor    %edx,%edx
xor    %ecx,%ecx
mov    0x120(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    0x0(%rbp,%rcx,4),%edx
mov    %edx,0x18(%rsp)
cmpl   $0x0,(%rbx,%rcx,4)
je     1930 <pred_+0x7b0>
mov    %eax,%edx
add    $0xffffffff,%eax
jmp    193b <pred_+0x7bb>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x14(%rsp),%edx
lea    0x1(%rdx),%esi
mov    %esi,0x14(%rsp)
movslq %edx,%rdx
mov    %ecx,(%rdi,%rdx,4)
add    $0x1,%rcx
movslq 0x1c(%rsp),%rdx
cmp    %rdx,%rcx
jge    1955 <pred_+0x7d5>
mov    0x18(%rsp),%edx
jmp    1910 <pred_+0x790>
test   %edx,%edx
jle    1d5b <pred_+0xbdb>
lea    0x30(%r12),%rax
mov    %rax,0x70(%rsp)
mov    0x30(%rsp),%rbx
lea    0x30(%rbx),%rax
mov    %rax,0x58(%rsp)
lea    0x18(%rbx),%rax
mov    %rax,0x8(%rsp)
lea    0x18(%r12),%rax
mov    %rax,0x20(%rsp)
lea    0x30(%r15),%rax
mov    %rax,0x68(%rsp)
lea    0x30(%r8),%rax
mov    %rax,0x60(%rsp)
lea    0x18(%r8),%rax
mov    %rax,0x38(%rsp)
lea    0x18(%r15),%r11
xor    %edx,%edx
jmp    19d2 <pred_+0x852>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
movslq 0x1c(%rsp),%rax
cmp    %rax,%rdx
mov    0x50(%rsp),%r12
mov    0x128(%rsp),%rbp
mov    %r10,%rdi
jge    1d60 <pred_+0xbe0>
movslq (%rdi,%rdx,4),%rax
mov    $0x2,%ecx
sub    0x0(%rbp,%rax,4),%ecx
mov    0x48(%rsp),%rax
mov    %ecx,(%rax,%rdx,4)
mov    (%rsp),%r8d
mov    (%rdi,%rdx,4),%r13d
test   %r8d,%r8d
jle    1bb0 <pred_+0xa30>
mov    %r13d,%eax
imul   %r8d,%eax
movslq %eax,%r10
cmp    $0x4,%r8d
jb     1a3b <pred_+0x8bb>
mov    %r8d,%eax
imul   %edx,%eax
movslq %eax,%r9
lea    (%rbx,%r9,8),%rax
lea    (%r10,%r8,1),%rcx
lea    (%r12,%rcx,8),%rcx
cmp    %rcx,%rax
jae    1adc <pred_+0x95c>
lea    (%r9,%r8,1),%rax
lea    (%rbx,%rax,8),%rax
lea    (%r12,%r10,8),%rcx
cmp    %rax,%rcx
jae    1adc <pred_+0x95c>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r8,%rcx
mov    %r8,%rsi
and    $0x3,%rsi
je     1a75 <pred_+0x8f5>
mov    %r8d,%ebp
imul   %edx,%ebp
movslq %ebp,%rbp
lea    (%rbx,%rbp,8),%rbp
lea    (%r12,%r10,8),%rbx
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1a60 <pred_+0x8e0>
cmp    $0x3,%rcx
mov    0x30(%rsp),%rbx
jb     1bb0 <pred_+0xa30>
mov    %r8d,%ecx
imul   %edx,%ecx
movslq %ecx,%rcx
mov    0x8(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
mov    0x20(%rsp),%rsi
lea    (%rsi,%r10,8),%rsi
nop
movsd  -0x18(%rsi,%rax,8),%xmm0
movsd  %xmm0,-0x18(%rcx,%rax,8)
movsd  -0x10(%rsi,%rax,8),%xmm0
movsd  %xmm0,-0x10(%rcx,%rax,8)
movsd  -0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rax,8)
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
add    $0x4,%rax
cmp    %rax,%r8
jne    1aa0 <pred_+0x920>
jmp    1bb0 <pred_+0xa30>
mov    %r8d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%r14
shr    $0x2,%r14
add    $0x1,%r14
test   %rcx,%rcx
je     1b6b <pred_+0x9eb>
mov    %r14,%rcx
movabs $0x7ffffffffffffffe,%rsi
and    %rsi,%rcx
mov    0x70(%rsp),%rsi
lea    (%rsi,%r10,8),%r12
mov    %r8d,%esi
imul   %edx,%esi
movslq %esi,%rsi
mov    0x58(%rsp),%rdi
lea    (%rdi,%rsi,8),%rbp
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%r12,%rsi,8),%xmm0
movups -0x20(%r12,%rsi,8),%xmm1
movups %xmm0,-0x30(%rbp,%rsi,8)
movups %xmm1,-0x20(%rbp,%rsi,8)
movupd -0x10(%r12,%rsi,8),%xmm0
movupd (%r12,%rsi,8),%xmm1
movupd %xmm0,-0x10(%rbp,%rsi,8)
movupd %xmm1,0x0(%rbp,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rcx
jne    1b30 <pred_+0x9b0>
jmp    1b6d <pred_+0x9ed>
xor    %esi,%esi
test   $0x1,%r14b
mov    0x50(%rsp),%r12
je     1b99 <pred_+0xa19>
lea    (%rsi,%r10,1),%rcx
movupd (%r12,%rcx,8),%xmm0
movupd 0x10(%r12,%rcx,8),%xmm1
add    %rsi,%r9
movupd %xmm0,(%rbx,%r9,8)
movupd %xmm1,0x10(%rbx,%r9,8)
cmp    %r8,%rax
mov    0x90(%rsp),%rdi
jne    1a3d <pred_+0x8bd>
nopw   0x0(%rax,%rax,1)
mov    %rdi,%r10
mov    0x4(%rsp),%r9d
test   %r9d,%r9d
jle    19b0 <pred_+0x830>
imul   %r9d,%r13d
mov    %edx,%eax
imul   %r9d,%eax
movslq %r13d,%r8
movslq %eax,%r14
cmp    $0x4,%r9d
jb     1c06 <pred_+0xa86>
mov    0x28(%rsp),%rsi
lea    (%rsi,%r14,8),%rax
lea    (%r8,%r9,1),%rcx
lea    (%r15,%rcx,8),%rcx
cmp    %rcx,%rax
jae    1c9c <pred_+0xb1c>
lea    (%r14,%r9,1),%rax
lea    (%rsi,%rax,8),%rax
lea    (%r15,%r8,8),%rcx
cmp    %rax,%rcx
jae    1c9c <pred_+0xb1c>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r9,%rcx
mov    %r9,%rsi
and    $0x3,%rsi
je     1c45 <pred_+0xac5>
mov    0x28(%rsp),%rdi
lea    (%rdi,%r14,8),%rdi
lea    (%r15,%r8,8),%rbp
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1c30 <pred_+0xab0>
cmp    $0x3,%rcx
jb     19b0 <pred_+0x830>
mov    0x38(%rsp),%rcx
lea    (%rcx,%r14,8),%rcx
lea    (%r11,%r8,8),%rsi
nopl   0x0(%rax)
movsd  -0x18(%rsi,%rax,8),%xmm0
movsd  %xmm0,-0x18(%rcx,%rax,8)
movsd  -0x10(%rsi,%rax,8),%xmm0
movsd  %xmm0,-0x10(%rcx,%rax,8)
movsd  -0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rax,8)
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
add    $0x4,%rax
cmp    %rax,%r9
jne    1c60 <pred_+0xae0>
jmp    19b0 <pred_+0x830>
mov    %r9d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rcx,%rcx
je     1d51 <pred_+0xbd1>
mov    %rbp,%rcx
movabs $0x7ffffffffffffffe,%rsi
ff ff 7f
and    %rsi,%rcx
mov    0x68(%rsp),%rsi
lea    (%rsi,%r8,8),%rdi
mov    0x60(%rsp),%rsi
lea    (%rsi,%r14,8),%rbx
xor    %esi,%esi
xchg   %ax,%ax
movups -0x30(%rdi,%rsi,8),%xmm0
movups -0x20(%rdi,%rsi,8),%xmm1
movups %xmm0,-0x30(%rbx,%rsi,8)
movups %xmm1,-0x20(%rbx,%rsi,8)
movupd -0x10(%rdi,%rsi,8),%xmm0
movupd (%rdi,%rsi,8),%xmm1
movupd %xmm0,-0x10(%rbx,%rsi,8)
movupd %xmm1,(%rbx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rcx
jne    1ce0 <pred_+0xb60>
test   $0x1,%bpl
je     1d3e <pred_+0xbbe>
lea    (%rsi,%r8,1),%rcx
movupd (%r15,%rcx,8),%xmm0
movupd 0x10(%r15,%rcx,8),%xmm1
add    %r14,%rsi
mov    0x28(%rsp),%rcx
movupd %xmm0,(%rcx,%rsi,8)
movupd %xmm1,0x10(%rcx,%rsi,8)
cmp    %r9,%rax
mov    0x30(%rsp),%rbx
je     19b0 <pred_+0x830>
jmp    1c08 <pred_+0xa88>
xor    %esi,%esi
test   $0x1,%bpl
jne    1d1a <pred_+0xb9a>
jmp    1d3e <pred_+0xbbe>
mov    0x4(%rsp),%r9d
mov    0x100(%rsp),%r8
test   %r9d,%r9d
jle    1f35 <pred_+0xdb5>
mov    %r9d,%ecx
cmp    $0x4,%r9d
jb     1da0 <pred_+0xc20>
mov    0x40(%rsp),%rbp
lea    0x0(,%rcx,8),%rax
add    %rbp,%rax
cmp    %r8,%rax
jbe    1e5b <pred_+0xcdb>
lea    (%r8,%rcx,8),%rax
cmp    %rbp,%rax
jbe    1e5b <pred_+0xcdb>
xor    %eax,%eax
mov    %rax,%rdx
not    %rdx
add    %rcx,%rdx
mov    %rcx,%rsi
and    $0x3,%rsi
je     1de6 <pred_+0xc66>
mov    0x40(%rsp),%rdi
nopl   0x0(%rax)
movsd  (%rdi,%rax,8),%xmm0
mulsd  (%r8,%rax,8),%xmm0
movsd  %xmm0,(%r8,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1dc0 <pred_+0xc40>
cmp    $0x3,%rdx
jae    1df5 <pred_+0xc75>
jmp    1f35 <pred_+0xdb5>
mov    0x40(%rsp),%rdi
cmp    $0x3,%rdx
jb     1f35 <pred_+0xdb5>
mov    %rdi,%rdx
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm0
mulsd  (%r8,%rax,8),%xmm0
movsd  %xmm0,(%r8,%rax,8)
movsd  0x8(%rdx,%rax,8),%xmm0
mulsd  0x8(%r8,%rax,8),%xmm0
movsd  %xmm0,0x8(%r8,%rax,8)
movsd  0x10(%rdx,%rax,8),%xmm0
mulsd  0x10(%r8,%rax,8),%xmm0
movsd  %xmm0,0x10(%r8,%rax,8)
movsd  0x18(%rdx,%rax,8),%xmm0
mulsd  0x18(%r8,%rax,8),%xmm0
movsd  %xmm0,0x18(%r8,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1e00 <pred_+0xc80>
jmp    1f35 <pred_+0xdb5>
mov    %ecx,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     24a2 <pred_+0x1322>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rdx,8),%xmm0
movupd 0x10(%rbp,%rdx,8),%xmm1
movupd (%r8,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r8,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd 0x20(%r8,%rdx,8),%xmm1
movupd 0x30(%r8,%rdx,8),%xmm3
movupd %xmm2,(%r8,%rdx,8)
movupd %xmm0,0x10(%r8,%rdx,8)
movupd 0x20(%rbp,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd 0x30(%rbp,%rdx,8),%xmm1
mulpd  %xmm3,%xmm1
movupd %xmm0,0x20(%r8,%rdx,8)
movupd %xmm1,0x30(%r8,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1e90 <pred_+0xd10>
test   $0x1,%sil
je     1f2c <pred_+0xdac>
movupd 0x0(%rbp,%rdx,8),%xmm0
movupd 0x10(%rbp,%rdx,8),%xmm1
movupd (%r8,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r8,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r8,%rdx,8)
movupd %xmm0,0x10(%r8,%rdx,8)
cmp    %rcx,%rax
jne    1da2 <pred_+0xc22>
mov    0x180(%rsp),%rbx
mov    0x110(%rsp),%rbp
mov    0x108(%rsp),%r14
movslq 0xa4(%rsp),%r12
cmpl   $0x0,0x7c(%rsp)
je     205a <pred_+0xeda>
mov    0x168(%rsp),%r8
mov    0x160(%rsp),%rcx
mov    0x158(%rsp),%rdx
mov    0x150(%rsp),%rsi
mov    0x148(%rsp),%rdi
mov    %rsp,%r13
mov    %r13,%r9
xor    %eax,%eax
push   %rbx
push   0x38(%rsp)
call   1040 <loess_ifit@plt>
add    $0x10,%rsp
mov    0x178(%rsp),%rax
cmpl   $0x0,(%rax)
je     2440 <pred_+0x12c0>
mov    0x138(%rsp),%rax
movsd  (%r14),%xmm0
mulsd  (%rax),%xmm0
movsd  %xmm0,0xc0(%rsp)
movslq (%rsp),%rdi
shl    $0x3,%rdi
mov    $0x61,%esi
xor    %eax,%eax
call   1050 <safe_malloc@plt>
movslq %eax,%rbx
sub    $0x8,%rsp
lea    0xc(%rsp),%rbp
lea    0x24(%rsp),%r10
lea    0xc8(%rsp),%r11
mov    %r14,%r8
lea    0x20(%rsp),%r14
lea    0x1c(%rsp),%r15
mov    0x88(%rsp),%rdi
mov    0x30(%rsp),%rsi
mov    0x38(%rsp),%rdx
mov    0x48(%rsp),%rcx
mov    0x118(%rsp),%r9
mov    $0x0,%eax
push   %r12
push   %rbx
push   %r13
push   %rbp
push   %r10
push   %r11
push   %r14
push   0x88(%rsp)
push   %r15
mov    0xd8(%rsp),%r15
call   1060 <loess_ise@plt>
add    $0x50,%rsp
mov    %rbx,%rdi
call   1030 <free@plt>
jmp    2128 <pred_+0xfa8>
mov    0x178(%rsp),%rax
cmpl   $0x0,(%rax)
je     20cb <pred_+0xf4b>
mov    %rsp,%r13
lea    0x4(%rsp),%r10
lea    0x1c(%rsp),%r11
lea    0x18(%rsp),%r14
lea    0x14(%rsp),%r15
lea    0xac(%rsp),%r9
mov    0x80(%rsp),%rdi
mov    0x28(%rsp),%rsi
mov    0x30(%rsp),%rdx
mov    0x40(%rsp),%rcx
xor    %eax,%eax
push   %r12
push   %rbx
push   %r13
push   %r10
push   %r11
push   %r14
push   0x78(%rsp)
push   %r15
mov    0xc8(%rsp),%r15
push   %rbp
push   0x150(%rsp)
call   1080 <loess_dfitse@plt>
add    $0x50,%rsp
jmp    2128 <pred_+0xfa8>
sub    $0x8,%rsp
lea    0x8(%rsp),%r13
lea    0xc(%rsp),%r10
lea    0x24(%rsp),%r11
mov    %r14,%rax
lea    0x20(%rsp),%r14
lea    0x1c(%rsp),%r15
mov    0x88(%rsp),%rdi
mov    0x30(%rsp),%rsi
mov    0x38(%rsp),%rdx
mov    %r8,%rcx
mov    %rax,%r8
mov    %rbp,%r9
xor    %eax,%eax
push   %rbx
push   %r13
push   %r10
push   %r11
push   %r14
push   0x78(%rsp)
push   %r15
mov    0xc8(%rsp),%r15
call   10a0 <loess_dfit@plt>
add    $0x40,%rsp
mov    0x178(%rsp),%rax
cmpl   $0x0,(%rax)
je     2440 <pred_+0x12c0>
mov    0x4(%rsp),%r11d
mov    (%rsp),%eax
test   %r11d,%r11d
mov    0x40(%rsp),%rbp
jle    2317 <pred_+0x1197>
movslq %eax,%r14
mov    %eax,%ecx
and    $0xfffffffe,%ecx
mov    %rcx,0x8(%rsp)
add    $0xfffffffffffffffe,%rcx
mov    %rcx,0x50(%rsp)
mov    %rcx,%rdx
shr    %rdx
add    $0x1,%rdx
mov    %rdx,%rcx
mov    %rdx,0x20(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x38(%rsp)
mov    %rax,%r13
neg    %r13
lea    0x10(%r12),%rdi
lea    0x0(,%r14,8),%r10
xor    %edx,%edx
mov    %r12,%rbx
jmp    21b3 <pred_+0x1033>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
add    %r10,%rdi
add    %r10,%rbx
cmp    %r11,%rdx
je     2317 <pred_+0x1197>
test   %eax,%eax
jle    21a0 <pred_+0x1020>
mov    %rdx,%r8
imul   %r14,%r8
cmp    $0x1,%eax
je     21f3 <pred_+0x1073>
lea    (%r12,%r8,8),%rcx
lea    0x8(,%rdx,8),%rsi
add    %rbp,%rsi
cmp    %rsi,%rcx
jae    2268 <pred_+0x10e8>
lea    (%r8,%rax,1),%rcx
lea    (%r12,%rcx,8),%rcx
lea    0x0(,%rdx,8),%rsi
add    %rbp,%rsi
cmp    %rcx,%rsi
jae    2268 <pred_+0x10e8>
xor    %ecx,%ecx
mov    %rcx,%rsi
test   $0x1,%al
je     221c <pred_+0x109c>
add    %rcx,%r8
movsd  (%r12,%r8,8),%xmm0
divsd  0x0(%rbp,%rdx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%r12,%r8,8)
mov    %rcx,%rsi
or     $0x1,%rsi
not    %rcx
cmp    %r13,%rcx
je     21a0 <pred_+0x1020>
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rsi,8),%xmm0
movsd  0x8(%rbx,%rsi,8),%xmm1
divsd  0x0(%rbp,%rdx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%rbx,%rsi,8)
divsd  0x0(%rbp,%rdx,8),%xmm1
mulsd  %xmm1,%xmm1
movsd  %xmm1,0x8(%rbx,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rax
jne    2230 <pred_+0x10b0>
jmp    21a0 <pred_+0x1020>
cmpq   $0x0,0x50(%rsp)
je     230b <pred_+0x118b>
movsd  0x0(%rbp,%rdx,8),%xmm0
unpcklpd %xmm0,%xmm0
mov    0x38(%rsp),%rcx
xor    %r9d,%r9d
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%rdi,%r9,8),%xmm1
movupd (%rdi,%r9,8),%xmm2
divpd  %xmm0,%xmm1
mulpd  %xmm1,%xmm1
movupd %xmm1,-0x10(%rdi,%r9,8)
divpd  %xmm0,%xmm2
mulpd  %xmm2,%xmm2
movupd %xmm2,(%rdi,%r9,8)
add    $0x4,%r9
add    $0xfffffffffffffffe,%rcx
jne    2290 <pred_+0x1110>
testb  $0x1,0x20(%rsp)
je     22f0 <pred_+0x1170>
add    %r8,%r9
movupd (%r12,%r9,8),%xmm0
mov    0x40(%rsp),%rcx
movsd  (%rcx,%rdx,8),%xmm1
unpcklpd %xmm1,%xmm1
divpd  %xmm1,%xmm0
mulpd  %xmm0,%xmm0
movupd %xmm0,(%r12,%r9,8)
mov    0x8(%rsp),%rsi
mov    %rsi,%rcx
cmp    %rax,%rsi
mov    0x40(%rsp),%rbp
je     21a0 <pred_+0x1020>
jmp    21f5 <pred_+0x1075>
xor    %r9d,%r9d
testb  $0x1,0x20(%rsp)
jne    22cb <pred_+0x114b>
jmp    22f0 <pred_+0x1170>
test   %eax,%eax
jle    2440 <pred_+0x12c0>
mov    0x188(%rsp),%r10
xor    %r13d,%r13d
xorpd  %xmm1,%xmm1
mov    %r12,%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
test   %r11d,%r11d
jle    23ed <pred_+0x126d>
movslq %eax,%r8
mov    %r11d,%r9d
lea    -0x1(%r9),%rax
mov    %r9d,%ecx
and    $0x3,%ecx
cmp    $0x3,%rax
jae    2370 <pred_+0x11f0>
xorpd  %xmm0,%xmm0
xor    %esi,%esi
jmp    23c2 <pred_+0x1242>
nopl   0x0(%rax,%rax,1)
and    $0xfffffffc,%r9d
mov    %r8,%rdi
shl    $0x4,%rdi
add    %r14,%rdi
mov    %r8,%rax
shl    $0x5,%rax
lea    (%r14,%r8,8),%rbx
lea    (%r8,%r8,2),%rdx
lea    (%r14,%rdx,8),%rbp
xorpd  %xmm0,%xmm0
xor    %edx,%edx
xor    %esi,%esi
nopl   0x0(%rax)
addsd  (%r14,%rdx,1),%xmm0
addsd  (%rbx,%rdx,1),%xmm0
addsd  (%rdi,%rdx,1),%xmm0
addsd  0x0(%rbp,%rdx,1),%xmm0
add    $0x4,%rsi
add    %rax,%rdx
cmp    %rsi,%r9
jne    23a0 <pred_+0x1220>
test   %rcx,%rcx
je     23ed <pred_+0x126d>
imul   %r8,%rsi
add    %r13,%rsi
lea    (%r12,%rsi,8),%rax
shl    $0x3,%r8
cs nopw 0x0(%rax,%rax,1)
addsd  (%rax),%xmm0
add    %r8,%rax
add    $0xffffffffffffffff,%rcx
jne    23e0 <pred_+0x1260>
movsd  (%r15),%xmm2
ucomisd %xmm1,%xmm0
jb     2400 <pred_+0x1280>
sqrtsd %xmm0,%xmm0
jmp    241b <pred_+0x129b>
xchg   %ax,%ax
mov    %r10,%rbx
movsd  %xmm2,0x8(%rsp)
call   1090 <sqrt@plt>
movsd  0x8(%rsp),%xmm2
xorpd  %xmm1,%xmm1
mov    %rbx,%r10
mulsd  %xmm0,%xmm2
movsd  %xmm2,(%r10,%r13,8)
add    $0x1,%r13
movslq (%rsp),%rax
cmp    %rax,%r13
jge    2440 <pred_+0x12c0>
mov    0x4(%rsp),%r11d
add    $0x8,%r14
jmp    2340 <pred_+0x11c0>
movslq 0xa8(%rsp),%rbx
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x98(%rsp),%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x90(%rsp),%rdi
call   1030 <free@plt>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%sil
jne    1efe <pred_+0xd7e>
jmp    1f2c <pred_+0xdac>

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

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