void hugeglasso(const double *S, double *W, double *T, int d, double ilambda) {
  int d2;
  d2 = d * d;
  int i, j, k;
  int rss_idx, w_idx;
  int tmp_i;
  int tmp_j, tmp_a;
  int gap_int;
  double gap_ext, gap_act;
  double thol_act = 1e-4;
  double thol_ext = 1e-4;
  int MAX_ITER_EXT = 100;
  int MAX_ITER_INT = 10000;
  int MAX_ITER_ACT = 10000;
  int iter_ext, iter_int, iter_act;
  int *idx_a = (int *)malloc((d2) * sizeof(int));
  int *idx_i = (int *)malloc((d2) * sizeof(int));
  int *size_a = (int *)malloc(d * sizeof(int));
  double *w1 = (double *)malloc(d * sizeof(double));
  double *ww = (double *)malloc(d * sizeof(double));
  int size_a_prev;
  int junk_a;
  double r;
  double tmp1, tmp2, tmp3, tmp4, tmp5, tmp6;
  for (i = 0; i < d; i++) {
    tmp_i = i * d;
    W[tmp_i + i] = S[tmp_i + i] + ilambda;
    size_a[i] = 0;
    tmp1 = T[tmp_i + i];
    T[tmp_i + i] = 0;
    idx_i[tmp_i + i] = -1;
    for (j = 0; j < i; j++) {
      if (T[tmp_i + j] != 0) {
        idx_a[tmp_i + size_a[i]] = j;
        size_a[i]++;
        idx_i[tmp_i + j] = -1;
        T[tmp_i + j] = -T[tmp_i + j] / tmp1;
      } else
        idx_i[tmp_i + j] = 1;
    }
    for (j = i + 1; j < d; j++) {
      if (T[tmp_i + j] != 0) {
        idx_a[tmp_i + size_a[i]] = j;
        size_a[i]++;
        idx_i[tmp_i + j] = -1;
        T[tmp_i + j] = -T[tmp_i + j] / tmp1;
      } else
        idx_i[tmp_i + j] = 1;
    }
  }
  gap_ext = 1;
  iter_ext = 0;
  while (gap_ext > thol_ext && iter_ext < MAX_ITER_EXT) {
    tmp1 = 0;
    tmp6 = 0;
    tmp5 = 0;
    for (i = 0; i < d; i++) {
      tmp_i = i * d;
      gap_int = 1;
      iter_int = 0;
      for (j = 0; j < d; j++)
        ww[j] = T[tmp_i + j];
      while (gap_int != 0 && iter_int < MAX_ITER_INT) {
        size_a_prev = size_a[i];
        for (j = 0; j < d; j++) {
          if (idx_i[tmp_i + j] != -1) {
            tmp_j = j * d;
            r = S[tmp_i + j];
            for (k = 0; k < size_a[i]; k++) {
              rss_idx = idx_a[tmp_i + k];
              r = r - W[tmp_j + rss_idx] * T[tmp_i + rss_idx];
            }
            if (r > ilambda) {
              w1[j] = (r - ilambda) / W[tmp_j + j];
              idx_a[tmp_i + size_a[i]] = j;
              size_a[i] = size_a[i] + 1;
              idx_i[tmp_i + j] = -1;
            } else if (r < -ilambda) {
              w1[j] = (r + ilambda) / W[tmp_j + j];
              idx_a[tmp_i + size_a[i]] = j;
              size_a[i] = size_a[i] + 1;
              idx_i[tmp_i + j] = -1;
            } else
              w1[j] = 0;
            T[tmp_i + j] = w1[j];
          }
        }
        gap_int = size_a[i] - size_a_prev;
        gap_act = 1;
        iter_act = 0;
        while (gap_act > thol_act && iter_act < MAX_ITER_ACT) {
          tmp3 = 0;
          tmp4 = 0;
          for (j = 0; j < size_a[i]; j++) {
            w_idx = idx_a[tmp_i + j];
            if (w_idx != -1) {
              tmp_a = w_idx * d;
              r = S[tmp_i + w_idx] + T[tmp_i + w_idx] * W[tmp_a + w_idx];
              for (k = 0; k < size_a[i]; k++) {
                rss_idx = idx_a[tmp_i + k];
                r = r - W[tmp_a + rss_idx] * T[tmp_i + rss_idx];
              }
              if (r > ilambda) {
                w1[w_idx] = (r - ilambda) / W[tmp_a + w_idx];
                tmp4 += w1[w_idx];
              } else if (r < -ilambda) {
                w1[w_idx] = (r + ilambda) / W[tmp_a + w_idx];
                tmp4 -= w1[w_idx];
              } else
                w1[w_idx] = 0;
              tmp3 = tmp3 + fabs(w1[w_idx] - T[tmp_i + w_idx]);
              T[tmp_i + w_idx] = w1[w_idx];
            }
          }
          gap_act = tmp3 / tmp4;
          iter_act++;
        }
        junk_a = 0;
        for (j = 0; j < size_a[i]; j++) {
          w_idx = idx_a[tmp_i + j];
          if (w1[w_idx] == 0) {
            junk_a++;
            idx_i[tmp_i + w_idx] = 1;
            idx_a[tmp_i + j] = -1;
          } else
            idx_a[tmp_i + j - junk_a] = w_idx;
        }
        size_a[i] = size_a[i] - junk_a;
        iter_int++;
      }
      for (j = 0; j < i; j++) {
        tmp2 = 0;
        tmp_j = j * d;
        for (k = 0; k < i; k++)
          tmp2 = tmp2 + T[tmp_i + k] * W[tmp_j + k];
        for (k = i + 1; k < d; k++)
          tmp2 = tmp2 + T[tmp_i + k] * W[tmp_j + k];
        W[tmp_i + j] = tmp2;
        W[tmp_j + i] = tmp2;
      }
      for (j = i + 1; j < d; j++) {
        tmp2 = 0;
        tmp_j = j * d;
        for (k = 0; k < i; k++)
          tmp2 = tmp2 + T[tmp_i + k] * W[tmp_j + k];
        for (k = i + 1; k < d; k++)
          tmp2 = tmp2 + T[tmp_i + k] * W[tmp_j + k];
        W[tmp_i + j] = tmp2;
        W[tmp_j + i] = tmp2;
      }
      for (j = 0; j < d; j++)
        tmp5 = tmp5 + fabs(ww[j] - T[tmp_i + j]);
      tmp6 = tmp6 + tmp4;
    }
    gap_ext = tmp5 / tmp6;
    iter_ext++;
  }
  for (i = 0; i < d; i++) {
    tmp2 = 0;
    for (j = 0; j < i; j++)
      tmp2 = tmp2 + W[i * d + j] * T[i * d + j];
    for (j = i + 1; j < d; j++)
      tmp2 = tmp2 + W[i * d + j] * T[i * d + j];
    tmp1 = 1 / (W[i * d + i] - tmp2);
    T[i * d + i] = tmp1;
    for (j = 0; j < i; j++)
      T[i * d + j] = -tmp1 * T[i * d + j];
    for (j = i + 1; j < d; j++)
      T[i * d + j] = -tmp1 * T[i * d + j];
  }
  free(idx_a);
  free(idx_i);
  free(size_a);
  free(w1);
  free(ww);
}


x86 assembly (clang, -O0):
<hugeglasso>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movsd  %xmm0,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movsd  0x1eaf(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0x1ea2(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x64,-0x74(%rbp)
movl   $0x2710,-0x78(%rbp)
movl   $0x2710,-0x7c(%rbp)
movslq -0x2c(%rbp),%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x90(%rbp)
movslq -0x2c(%rbp),%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x98(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xa0(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xa8(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xb0(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1485 <hugeglasso+0x365>
mov    -0x30(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa0(%rbp),%rax
movslq -0x30(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x98(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movl   $0xffffffff,(%rax,%rcx,4)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1375 <hugeglasso+0x255>
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    12b7 <hugeglasso+0x197>
jp     12b7 <hugeglasso+0x197>
jmp    134b <hugeglasso+0x22b>
mov    -0x34(%rbp),%edx
mov    -0x90(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0xa0(%rbp),%rsi
movslq -0x30(%rbp),%rdi
add    (%rsi,%rdi,4),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xa0(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x98(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0xc8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1362 <hugeglasso+0x242>
mov    -0x98(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    1367 <hugeglasso+0x247>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1281 <hugeglasso+0x161>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1472 <hugeglasso+0x352>
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    13b4 <hugeglasso+0x294>
jp     13b4 <hugeglasso+0x294>
jmp    1448 <hugeglasso+0x328>
mov    -0x34(%rbp),%edx
mov    -0x90(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0xa0(%rbp),%rsi
movslq -0x30(%rbp),%rdi
add    (%rsi,%rdi,4),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xa0(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x98(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0xc8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    145f <hugeglasso+0x33f>
mov    -0x98(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    1464 <hugeglasso+0x344>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    137e <hugeglasso+0x25e>
jmp    1477 <hugeglasso+0x357>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11e3 <hugeglasso+0xc3>
movsd  0x1b7b(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x80(%rbp)
movsd  -0x58(%rbp),%xmm0
xor    %eax,%eax
ucomisd -0x70(%rbp),%xmm0
mov    %al,-0xf1(%rbp)
jbe    14c0 <hugeglasso+0x3a0>
mov    -0x80(%rbp),%eax
cmp    -0x74(%rbp),%eax
setl   %al
mov    %al,-0xf1(%rbp)
mov    -0xf1(%rbp),%al
test   $0x1,%al
jne    14d3 <hugeglasso+0x3b3>
jmp    1f88 <hugeglasso+0xe68>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1f65 <hugeglasso+0xe45>
mov    -0x30(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x50(%rbp)
movl   $0x0,-0x84(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1565 <hugeglasso+0x445>
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xb0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1529 <hugeglasso+0x409>
jmp    156a <hugeglasso+0x44a>
xor    %eax,%eax
cmpl   $0x0,-0x50(%rbp)
mov    %al,-0xf2(%rbp)
je     158e <hugeglasso+0x46e>
mov    -0x84(%rbp),%eax
cmp    -0x78(%rbp),%eax
setl   %al
mov    %al,-0xf2(%rbp)
mov    -0xf2(%rbp),%al
test   $0x1,%al
jne    15a1 <hugeglasso+0x481>
jmp    1c8f <hugeglasso+0xb6f>
mov    -0xa0(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xb4(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    183f <hugeglasso+0x71f>
mov    -0x98(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
je     182c <hugeglasso+0x70c>
mov    -0x34(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0xa0(%rbp),%rcx
movslq -0x30(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    169b <hugeglasso+0x57b>
mov    -0x90(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
movsd  -0xc0(%rbp),%xmm1
ff
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    160d <hugeglasso+0x4ed>
movsd  -0xc0(%rbp),%xmm0
ff
ucomisd -0x28(%rbp),%xmm0
jbe    1739 <hugeglasso+0x619>
movsd  -0xc0(%rbp),%xmm0
ff
subsd  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edx
mov    -0x90(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0xa0(%rbp),%rsi
movslq -0x30(%rbp),%rdi
add    (%rsi,%rdi,4),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xa0(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0xa0(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x98(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movl   $0xffffffff,(%rax,%rcx,4)
jmp    180a <hugeglasso+0x6ea>
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    17f2 <hugeglasso+0x6d2>
movsd  -0xc0(%rbp),%xmm0
ff
addsd  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edx
mov    -0x90(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0xa0(%rbp),%rsi
movslq -0x30(%rbp),%rdi
add    (%rsi,%rdi,4),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xa0(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0xa0(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x98(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movl   $0xffffffff,(%rax,%rcx,4)
jmp    1805 <hugeglasso+0x6e5>
mov    -0xa8(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    180a <hugeglasso+0x6ea>
mov    -0xa8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1831 <hugeglasso+0x711>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15bc <hugeglasso+0x49c>
mov    -0xa0(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    -0xb4(%rbp),%eax
mov    %eax,-0x50(%rbp)
movsd  0x17aa(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x88(%rbp)
movsd  -0x60(%rbp),%xmm0
xor    %eax,%eax
ucomisd -0x68(%rbp),%xmm0
mov    %al,-0xf3(%rbp)
jbe    1897 <hugeglasso+0x777>
mov    -0x88(%rbp),%eax
cmp    -0x7c(%rbp),%eax
setl   %al
mov    %al,-0xf3(%rbp)
mov    -0xf3(%rbp),%al
test   $0x1,%al
jne    18aa <hugeglasso+0x78a>
jmp    1b87 <hugeglasso+0xa67>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0xa0(%rbp),%rcx
movslq -0x30(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1b5e <hugeglasso+0xa3e>
mov    -0x90(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
cmpl   $0xffffffff,-0x40(%rbp)
je     1b4b <hugeglasso+0xa2b>
mov    -0x40(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0xa0(%rbp),%rcx
movslq -0x30(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    19e3 <hugeglasso+0x8c3>
mov    -0x90(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
movsd  -0xc0(%rbp),%xmm1
ff
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1955 <hugeglasso+0x835>
movsd  -0xc0(%rbp),%xmm0
ff
ucomisd -0x28(%rbp),%xmm0
jbe    1a4a <hugeglasso+0x92a>
movsd  -0xc0(%rbp),%xmm0
ff
subsd  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    1ae8 <hugeglasso+0x9c8>
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    1ad0 <hugeglasso+0x9b0>
movsd  -0xc0(%rbp),%xmm0
ff
addsd  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xe0(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    1ae3 <hugeglasso+0x9c3>
mov    -0xa8(%rbp),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ae8 <hugeglasso+0x9c8>
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0xa8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
movaps 0x14f7(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0xa8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b50 <hugeglasso+0xa30>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    18c7 <hugeglasso+0x7a7>
movsd  -0xd8(%rbp),%xmm0
ff
divsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    186d <hugeglasso+0x74d>
movl   $0x0,-0xb8(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0xa0(%rbp),%rcx
movslq -0x30(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1c59 <hugeglasso+0xb39>
mov    -0x90(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
mov    -0xa8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1c2a <hugeglasso+0xb0a>
jp     1c2a <hugeglasso+0xb0a>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x90(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movl   $0xffffffff,(%rax,%rcx,4)
jmp    1c46 <hugeglasso+0xb26>
mov    -0x40(%rbp),%edx
mov    -0x90(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
sub    -0xb8(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1c4b <hugeglasso+0xb2b>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1b98 <hugeglasso+0xa78>
mov    -0xa0(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
sub    -0xb8(%rbp),%edx
mov    -0xa0(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    156a <hugeglasso+0x44a>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1db5 <hugeglasso+0xc95>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x34(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1d14 <hugeglasso+0xbf4>
movsd  -0xd0(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1cbe <hugeglasso+0xb9e>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1d73 <hugeglasso+0xc53>
movsd  -0xd0(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1d1d <hugeglasso+0xbfd>
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1c96 <hugeglasso+0xb76>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1edd <hugeglasso+0xdbd>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x34(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1e3c <hugeglasso+0xd1c>
movsd  -0xd0(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1de6 <hugeglasso+0xcc6>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1e9b <hugeglasso+0xd7b>
movsd  -0xd0(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1e45 <hugeglasso+0xd25>
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1dbe <hugeglasso+0xc9e>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1f3f <hugeglasso+0xe1f>
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0xb0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
movaps 0x10ef(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1ee4 <hugeglasso+0xdc4>
movsd  -0xf0(%rbp),%xmm0
ff
addsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14fb <hugeglasso+0x3db>
movsd  -0xe8(%rbp),%xmm0
ff
divsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1499 <hugeglasso+0x379>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    21af <hugeglasso+0x108f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    200b <hugeglasso+0xeeb>
movsd  -0xd0(%rbp),%xmm1
ff
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1fad <hugeglasso+0xe8d>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    2072 <hugeglasso+0xf52>
movsd  -0xd0(%rbp),%xmm1
ff
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2014 <hugeglasso+0xef4>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  -0xd0(%rbp),%xmm1
ff
movsd  0xf70(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    212e <hugeglasso+0x100e>
movsd  -0xc8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    20c9 <hugeglasso+0xfa9>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    219c <hugeglasso+0x107c>
movsd  -0xc8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2137 <hugeglasso+0x1017>
jmp    21a1 <hugeglasso+0x1081>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1f8f <hugeglasso+0xe6f>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<hugeglasso>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
movapd %xmm0,0x110(%rsp)
mov    %ecx,%r14d
mov    %rdx,%rbx
mov    %rsi,%rbp
mov    %rdi,0x30(%rsp)
mov    %ecx,%r13d
imul   %r13d,%r13d
shl    $0x2,%r13
mov    %r13,%rdi
call   1050 <malloc@plt>
mov    %rax,%r15
mov    %r13,%rdi
call   1050 <malloc@plt>
mov    %rax,0x48(%rsp)
mov    %r14d,0xc(%rsp)
movslq %r14d,%r14
lea    0x0(,%r14,4),%rdi
mov    %rdi,0xb0(%rsp)
call   1050 <malloc@plt>
mov    %rax,0x50(%rsp)
lea    0x0(,%r14,8),%r12
mov    %r12,%rdi
call   1050 <malloc@plt>
mov    %rax,0x38(%rsp)
mov    %r12,0x60(%rsp)
mov    %r12,%rdi
call   1050 <malloc@plt>
movapd 0x110(%rsp),%xmm7
mov    %rax,0x70(%rsp)
mov    %r14d,%edx
mov    %r14,0x10(%rsp)
test   %r14d,%r14d
mov    %rdx,0x18(%rsp)
jle    13a8 <hugeglasso+0x278>
mov    0x48(%rsp),%r13
mov    %r13,%r14
add    $0x4,%r14
mov    0x10(%rsp),%rax
lea    0x4(,%rax,4),%rcx
mov    %rcx,0x20(%rsp)
lea    0x8(%rbx),%r12
lea    0x8(,%rax,8),%rax
mov    %rax,0x28(%rsp)
neg    %rdx
mov    %rdx,0x58(%rsp)
mov    $0x1,%r11d
xor    %edi,%edi
xorpd  %xmm0,%xmm0
movapd 0x1dd2(%rip),%xmm1
mov    %rbx,%rcx
jmp    126e <hugeglasso+0x13e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r11
add    0xb0(%rsp),%r13
add    0x60(%rsp),%rcx
add    0x20(%rsp),%r14
add    0x28(%rsp),%r12
mov    0x18(%rsp),%rdx
mov    0x40(%rsp),%rdi
cmp    %rdx,%rdi
je     13a8 <hugeglasso+0x278>
mov    %rdi,%rax
imul   0x10(%rsp),%rax
mov    %edi,%edx
imul   0xc(%rsp),%edx
movslq %edx,%rdx
add    %rdi,%rdx
mov    0x30(%rsp),%rsi
movsd  (%rsi,%rdx,8),%xmm2
addsd  %xmm7,%xmm2
movsd  %xmm2,0x0(%rbp,%rdx,8)
mov    0x50(%rsp),%rsi
movl   $0x0,(%rsi,%rdi,4)
movsd  (%rbx,%rdx,8),%xmm2
movq   $0x0,(%rbx,%rdx,8)
mov    0x48(%rsp),%rsi
movl   $0xffffffff,(%rsi,%rdx,4)
mov    $0x0,%r8d
test   %rdi,%rdi
je     1320 <hugeglasso+0x1f0>
xor    %r8d,%r8d
xor    %esi,%esi
jmp    1308 <hugeglasso+0x1d8>
nop
movslq %r8d,%r8
lea    (%rax,%r8,1),%rdx
mov    %esi,(%r15,%rdx,4)
add    $0x1,%r8d
mov    0x50(%rsp),%rdx
mov    %r8d,(%rdx,%rdi,4)
xorpd  %xmm1,%xmm3
divsd  %xmm2,%xmm3
movsd  %xmm3,(%rcx,%rsi,8)
mov    $0xffffffff,%edx
mov    %edx,0x0(%r13,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rdi
je     1320 <hugeglasso+0x1f0>
movsd  (%rcx,%rsi,8),%xmm3
ucomisd %xmm0,%xmm3
jne    12d0 <hugeglasso+0x1a0>
jp     12d0 <hugeglasso+0x1a0>
mov    $0x1,%edx
jmp    12fa <hugeglasso+0x1ca>
nopl   0x0(%rax)
lea    0x1(%rdi),%rdx
mov    %rdx,0x40(%rsp)
cmp    0x10(%rsp),%rdx
jge    1240 <hugeglasso+0x110>
mov    0x58(%rsp),%rdx
lea    (%rdx,%r11,1),%r10
xor    %esi,%esi
jmp    1393 <hugeglasso+0x263>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %r8d,%r8
lea    (%rax,%r8,1),%rdx
lea    (%r11,%rsi,1),%r9d
mov    %r9d,(%r15,%rdx,4)
add    $0x1,%r8d
mov    0x50(%rsp),%rdx
mov    %r8d,(%rdx,%rdi,4)
xorpd  %xmm1,%xmm3
divsd  %xmm2,%xmm3
movsd  %xmm3,(%r12,%rsi,8)
mov    $0xffffffff,%edx
mov    %edx,(%r14,%rsi,4)
add    $0x1,%rsi
mov    %r10,%rdx
add    %rsi,%rdx
je     1240 <hugeglasso+0x110>
movsd  (%r12,%rsi,8),%xmm3
ucomisd %xmm0,%xmm3
jne    1350 <hugeglasso+0x220>
jp     1350 <hugeglasso+0x220>
mov    $0x1,%edx
jmp    137f <hugeglasso+0x24f>
movapd 0x1c4f(%rip),%xmm8
xorpd  %xmm7,%xmm8
lea    0x0(,%rdx,8),%rax
mov    %rax,0xf8(%rsp)
lea    -0x1(%rdx),%rax
mov    %rax,0xa0(%rsp)
mov    %edx,%esi
and    $0xfffffffe,%esi
lea    0x4(%r15),%rax
mov    %rax,0xf0(%rsp)
lea    0x8(%rbx),%rax
mov    %rax,0x80(%rsp)
lea    0x8(%rbp),%rax
mov    %rax,0xe0(%rsp)
mov    0x10(%rsp),%rax
lea    0x8(%rbp,%rax,8),%rcx
mov    %rcx,0xd0(%rsp)
lea    0x0(%rbp,%rax,8),%rcx
mov    %rcx,0xc8(%rsp)
lea    0x8(,%rax,8),%rax
mov    %rax,0xa8(%rsp)
xor    %eax,%eax
mov    0x70(%rsp),%r12
movapd %xmm8,0x120(%rsp)
mov    %rsi,0xe8(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpl   $0x0,0xc(%rsp)
jle    214c <hugeglasso+0x101c>
mov    %rax,0xd8(%rsp)
xorpd  %xmm0,%xmm0
mov    $0x1,%eax
mov    %rax,0xb8(%rsp)
mov    0xc8(%rsp),%rax
mov    %rax,0x98(%rsp)
mov    0xd0(%rsp),%rax
mov    %rax,0x90(%rsp)
mov    %rdx,0x78(%rsp)
mov    %rbp,0xc0(%rsp)
mov    %rbx,0x88(%rsp)
xor    %r8d,%r8d
xorpd  %xmm5,%xmm5
jmp    1528 <hugeglasso+0x3f8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x100(%rsp),%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
addq   $0x1,0xb8(%rsp)
addq   $0x8,0x88(%rsp)
addq   $0x8,0xc0(%rsp)
addq   $0xffffffffffffffff,0x78(%rsp)
mov    0x90(%rsp),%rax
add    0x60(%rsp),%rax
mov    %rax,0x90(%rsp)
mov    0x98(%rsp),%rax
add    0xa8(%rsp),%rax
mov    %rax,0x98(%rsp)
cmp    %rdx,%r8
je     1cf0 <hugeglasso+0xbc0>
movapd %xmm5,0x130(%rsp)
movsd  %xmm0,0x100(%rsp)
mov    %r8,%r13
mov    %r8,%r14
imul   0x10(%rsp),%r14
mov    %r13d,%eax
imul   0xc(%rsp),%eax
cltq
lea    (%rbx,%rax,8),%rsi
mov    %r12,%rdi
mov    0xf8(%rsp),%rdx
call   1040 <memcpy@plt>
movapd 0x1aa3(%rip),%xmm11
xorpd  %xmm10,%xmm10
movsd  0x1aa5(%rip),%xmm9
movapd 0x120(%rsp),%xmm8
movapd 0x110(%rsp),%xmm7
mov    0x18(%rsp),%rsi
mov    0x50(%rsp),%rax
mov    (%rax,%r13,4),%r12d
mov    0xb0(%rsp),%rdx
mov    %r13,0x28(%rsp)
imul   %r13,%rdx
mov    0xf0(%rsp),%rax
lea    (%rax,%rdx,1),%rcx
add    %r15,%rdx
mov    %rdx,0x108(%rsp)
xor    %eax,%eax
mov    %rax,0x68(%rsp)
nopl   0x0(%rax,%rax,1)
xor    %r10d,%r10d
mov    %r12d,0x58(%rsp)
jmp    162e <hugeglasso+0x4fe>
nopw   0x0(%rax,%rax,1)
subsd  %xmm7,%xmm0
movslq %edx,%rax
add    %r10,%rax
divsd  0x0(%rbp,%rax,8),%xmm0
mov    0x38(%rsp),%rax
movsd  %xmm0,(%rax,%r10,8)
movslq %r12d,%rax
add    %r14,%rax
mov    %r10d,(%r15,%rax,4)
add    $0x1,%r12d
mov    0x48(%rsp),%rax
movl   $0xffffffff,(%rax,%r9,4)
ff
mov    0x18(%rsp),%rsi
movsd  %xmm0,(%rbx,%r9,8)
add    $0x1,%r10
cmp    %rsi,%r10
je     1750 <hugeglasso+0x620>
lea    (%r10,%r14,1),%r9
mov    0x48(%rsp),%rax
cmpl   $0xffffffff,(%rax,%r9,4)
je     1621 <hugeglasso+0x4f1>
mov    0x30(%rsp),%rax
movsd  (%rax,%r9,8),%xmm0
test   %r12d,%r12d
jle    16e0 <hugeglasso+0x5b0>
mov    %r10,%rsi
imul   0x10(%rsp),%rsi
mov    %r12d,%r8d
cmp    $0x1,%r12d
jne    1668 <hugeglasso+0x538>
xor    %edx,%edx
jmp    16be <hugeglasso+0x58e>
mov    %r8d,%r11d
and    $0xfffffffe,%r11d
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq -0x4(%rcx,%rdx,4),%rax
lea    (%rsi,%rax,1),%rdi
movsd  0x0(%rbp,%rdi,8),%xmm1
add    %r14,%rax
mulsd  (%rbx,%rax,8),%xmm1
movslq (%rcx,%rdx,4),%rax
lea    (%rsi,%rax,1),%rdi
movsd  0x0(%rbp,%rdi,8),%xmm2
add    %r14,%rax
mulsd  (%rbx,%rax,8),%xmm2
subsd  %xmm1,%xmm0
subsd  %xmm2,%xmm0
add    $0x2,%rdx
cmp    %rdx,%r11
jne    1680 <hugeglasso+0x550>
test   $0x1,%r8b
je     16e0 <hugeglasso+0x5b0>
add    %r14,%rdx
movslq (%r15,%rdx,4),%rax
add    %rax,%rsi
movsd  0x0(%rbp,%rsi,8),%xmm1
add    %r14,%rax
mulsd  (%rbx,%rax,8),%xmm1
subsd  %xmm1,%xmm0
mov    %r10d,%edx
imul   0xc(%rsp),%edx
ucomisd %xmm7,%xmm0
ja     15e0 <hugeglasso+0x4b0>
ucomisd %xmm0,%xmm8
mov    0x18(%rsp),%rsi
jbe    1739 <hugeglasso+0x609>
addsd  %xmm7,%xmm0
movslq %edx,%rax
add    %r10,%rax
divsd  0x0(%rbp,%rax,8),%xmm0
mov    0x38(%rsp),%rax
movsd  %xmm0,(%rax,%r10,8)
movslq %r12d,%rax
add    %r14,%rax
mov    %r10d,(%r15,%rax,4)
add    $0x1,%r12d
mov    0x48(%rsp),%rax
movl   $0xffffffff,(%rax,%r9,4)
ff
jmp    161b <hugeglasso+0x4eb>
mov    0x38(%rsp),%rax
movq   $0x0,(%rax,%r10,8)
xorpd  %xmm0,%xmm0
jmp    161b <hugeglasso+0x4eb>
nop
mov    %r12d,%esi
mov    %esi,%edx
and    $0xfffffffe,%edx
movl   $0x0,0x20(%rsp)
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   %r12d,%r12d
jle    1970 <hugeglasso+0x840>
mov    %rax,0x40(%rsp)
xorpd  %xmm0,%xmm0
xor    %r8d,%r8d
xorpd  %xmm1,%xmm1
jmp    17cb <hugeglasso+0x69b>
nopl   0x0(%rax,%rax,1)
subsd  %xmm7,%xmm3
divsd  %xmm4,%xmm3
mov    0x38(%rsp),%rax
movsd  %xmm3,(%rax,%r10,8)
addsd  %xmm3,%xmm0
movapd %xmm3,%xmm4
subsd  %xmm2,%xmm4
andpd  %xmm11,%xmm4
addsd  %xmm4,%xmm1
movsd  %xmm3,(%rbx,%r9,8)
add    $0x1,%r8
cmp    %rsi,%r8
je     18d0 <hugeglasso+0x7a0>
lea    (%r8,%r14,1),%rdi
movslq (%r15,%rdi,4),%r10
cmp    $0xffffffffffffffff,%r10
je     17be <hugeglasso+0x68e>
mov    %r10d,%edi
imul   0xc(%rsp),%edi
lea    (%r14,%r10,1),%r9
lea    (%rdi,%r10,1),%eax
movsd  (%rbx,%r9,8),%xmm2
cltq
movsd  0x0(%rbp,%rax,8),%xmm4
movapd %xmm2,%xmm3
mulsd  %xmm4,%xmm3
mov    0x30(%rsp),%rax
addsd  (%rax,%r9,8),%xmm3
movslq %edi,%r11
xor    %r13d,%r13d
cmp    $0x1,%r12d
je     185e <hugeglasso+0x72e>
cs nopw 0x0(%rax,%rax,1)
movslq -0x4(%rcx,%r13,4),%rax
lea    (%rax,%r11,1),%rdi
movsd  0x0(%rbp,%rdi,8),%xmm5
add    %r14,%rax
mulsd  (%rbx,%rax,8),%xmm5
movslq (%rcx,%r13,4),%rax
lea    (%rax,%r11,1),%rdi
movsd  0x0(%rbp,%rdi,8),%xmm6
add    %r14,%rax
mulsd  (%rbx,%rax,8),%xmm6
subsd  %xmm5,%xmm3
subsd  %xmm6,%xmm3
add    $0x2,%r13
cmp    %r13,%rdx
jne    1820 <hugeglasso+0x6f0>
test   $0x1,%sil
je     1881 <hugeglasso+0x751>
add    %r14,%r13
movslq (%r15,%r13,4),%rax
add    %rax,%r11
movsd  0x0(%rbp,%r11,8),%xmm5
add    %r14,%rax
mulsd  (%rbx,%rax,8),%xmm5
subsd  %xmm5,%xmm3
ucomisd %xmm7,%xmm3
ja     1790 <hugeglasso+0x660>
ucomisd %xmm3,%xmm8
jbe    18ae <hugeglasso+0x77e>
addsd  %xmm7,%xmm3
divsd  %xmm4,%xmm3
mov    0x38(%rsp),%rax
movsd  %xmm3,(%rax,%r10,8)
subsd  %xmm3,%xmm0
jmp    17a7 <hugeglasso+0x677>
mov    0x38(%rsp),%rax
movq   $0x0,(%rax,%r10,8)
xorpd  %xmm3,%xmm3
jmp    17a7 <hugeglasso+0x677>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
divsd  %xmm0,%xmm1
ucomisd %xmm9,%xmm1
mov    0x40(%rsp),%rdi
jbe    18ef <hugeglasso+0x7bf>
lea    0x1(%rdi),%eax
cmp    $0x270f,%edi
jb     1770 <hugeglasso+0x640>
test   %r12d,%r12d
jle    1974 <hugeglasso+0x844>
movl   $0x0,0x20(%rsp)
mov    0x108(%rsp),%rdx
jmp    192c <hugeglasso+0x7fc>
nopw   0x0(%rax,%rax,1)
movslq 0x20(%rsp),%rdi
shl    $0x2,%rdi
mov    %rdx,%rax
sub    %rdi,%rax
mov    %r8d,(%rax)
add    $0x4,%rdx
add    $0xffffffffffffffff,%rsi
je     1974 <hugeglasso+0x844>
mov    (%rdx),%r8d
movslq %r8d,%rdi
mov    0x38(%rsp),%rax
movsd  (%rax,%rdi,8),%xmm1
ucomisd %xmm10,%xmm1
jne    1910 <hugeglasso+0x7e0>
jp     1910 <hugeglasso+0x7e0>
addl   $0x1,0x20(%rsp)
add    %r14,%rdi
mov    0x48(%rsp),%rax
movl   $0x1,(%rax,%rdi,4)
movl   $0xffffffff,(%rdx)
jmp    1922 <hugeglasso+0x7f2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
mov    0x18(%rsp),%rsi
mov    %r12d,%eax
sub    0x20(%rsp),%eax
cmp    0x58(%rsp),%r12d
je     19a7 <hugeglasso+0x877>
mov    0x68(%rsp),%rdx
lea    0x1(%rdx),%r8d
mov    %eax,%r12d
cmp    $0x270f,%edx
mov    %r8d,%edx
mov    %rdx,0x68(%rsp)
jb     15d0 <hugeglasso+0x4a0>
mov    0x50(%rsp),%rcx
mov    0x28(%rsp),%rdx
mov    %eax,(%rcx,%rdx,4)
mov    %rdx,%rcx
test   %rdx,%rdx
movapd 0x164e(%rip),%xmm4
movapd 0x130(%rsp),%xmm5
je     1b00 <hugeglasso+0x9d0>
lea    0x1(%rcx),%r8
mov    %rcx,%r11
and    $0xfffffffffffffffe,%r11
mov    0x80(%rsp),%rax
lea    (%rax,%r14,8),%rdx
mov    0x88(%rsp),%rax
lea    (%rax,%r14,8),%r12
mov    0xc0(%rsp),%rdi
mov    0xe0(%rsp),%rax
xor    %r9d,%r9d
mov    0x78(%rsp),%rsi
jmp    1a44 <hugeglasso+0x914>
xchg   %ax,%ax
lea    (%r9,%r14,1),%rcx
movsd  %xmm1,0x0(%rbp,%rcx,8)
mov    0x28(%rsp),%r13
add    %r13,%r10
movsd  %xmm1,0x0(%rbp,%r10,8)
add    $0x1,%r9
mov    0x60(%rsp),%rcx
add    %rcx,%rax
add    %rcx,%rdi
mov    %r13,%rcx
cmp    %r13,%r9
je     1b06 <hugeglasso+0x9d6>
cmp    $0x1,%rcx
jne    1a60 <hugeglasso+0x930>
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
jmp    1a9b <hugeglasso+0x96b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm2,%xmm2
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rdx,%rcx,8),%xmm3
movsd  (%rdx,%rcx,8),%xmm1
mulsd  -0x8(%rax,%rcx,8),%xmm3
mulsd  (%rax,%rcx,8),%xmm1
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm1
add    $0x2,%rcx
movapd %xmm1,%xmm2
cmp    %rcx,%r11
jne    1a70 <hugeglasso+0x940>
mov    %r9,%r10
imul   0x10(%rsp),%r10
testb  $0x1,0x28(%rsp)
je     1ac6 <hugeglasso+0x996>
lea    (%rcx,%r14,1),%rsi
movsd  (%rbx,%rsi,8),%xmm2
mov    0x78(%rsp),%rsi
add    %r10,%rcx
mulsd  0x0(%rbp,%rcx,8),%xmm2
addsd  %xmm2,%xmm1
cmp    0x10(%rsp),%r8
jge    1a10 <hugeglasso+0x8e0>
mov    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
movsd  (%r12,%rcx,8),%xmm2
mulsd  (%rdi,%rcx,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    1ae0 <hugeglasso+0x9b0>
jmp    1a10 <hugeglasso+0x8e0>
nopl   (%rax)
mov    $0x1,%r8d
cmp    0x10(%rsp),%r8
jge    1c3d <hugeglasso+0xb0d>
mov    %rcx,%r11
and    $0xfffffffffffffffe,%r11
mov    0x80(%rsp),%rax
lea    (%rax,%r14,8),%r12
mov    0x88(%rsp),%rax
lea    (%rax,%r14,8),%rax
mov    0x98(%rsp),%rsi
mov    0x90(%rsp),%rdi
mov    0xb8(%rsp),%r9
nopl   0x0(%rax,%rax,1)
mov    %r9,%r10
imul   0x10(%rsp),%r10
test   %rcx,%rcx
je     1b70 <hugeglasso+0xa40>
cmp    $0x1,%rcx
jne    1b80 <hugeglasso+0xa50>
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
jmp    1bbd <hugeglasso+0xa8d>
nopl   0x0(%rax)
xorpd  %xmm1,%xmm1
jmp    1bda <hugeglasso+0xaaa>
cs nopw 0x0(%rax,%rax,1)
xorpd  %xmm2,%xmm2
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%r12,%rcx,8),%xmm3
movsd  (%r12,%rcx,8),%xmm1
mulsd  -0x8(%rdi,%rcx,8),%xmm3
mulsd  (%rdi,%rcx,8),%xmm1
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm1
add    $0x2,%rcx
movapd %xmm1,%xmm2
cmp    %rcx,%r11
jne    1b90 <hugeglasso+0xa60>
testb  $0x1,0x28(%rsp)
je     1bda <hugeglasso+0xaaa>
lea    (%rcx,%r14,1),%rdx
movsd  (%rbx,%rdx,8),%xmm2
add    %r10,%rcx
mulsd  0x0(%rbp,%rcx,8),%xmm2
addsd  %xmm2,%xmm1
mov    $0x1,%ecx
mov    0x78(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax,%rcx,8),%xmm2
mulsd  (%rsi,%rcx,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1bf0 <hugeglasso+0xac0>
lea    (%r9,%r14,1),%rcx
movsd  %xmm1,0x0(%rbp,%rcx,8)
mov    0x28(%rsp),%rdx
add    %rdx,%r10
movsd  %xmm1,0x0(%rbp,%r10,8)
add    $0x1,%r9
mov    0x60(%rsp),%rcx
add    %rcx,%rdi
add    %rcx,%rsi
mov    %rdx,%rcx
cmp    0x18(%rsp),%r9
jne    1b50 <hugeglasso+0xa20>
cmpq   $0x0,0xa0(%rsp)
je     1cb0 <hugeglasso+0xb80>
mov    0x80(%rsp),%rax
lea    (%rax,%r14,8),%rcx
xor    %eax,%eax
movapd %xmm5,%xmm1
mov    0x70(%rsp),%r12
mov    0x18(%rsp),%rdx
mov    0xe8(%rsp),%rsi
nopl   0x0(%rax)
movsd  (%r12,%rax,8),%xmm2
movsd  0x8(%r12,%rax,8),%xmm5
subsd  -0x8(%rcx,%rax,8),%xmm2
andpd  %xmm4,%xmm2
addsd  %xmm1,%xmm2
subsd  (%rcx,%rax,8),%xmm5
andpd  %xmm4,%xmm5
addsd  %xmm2,%xmm5
add    $0x2,%rax
movapd %xmm5,%xmm1
cmp    %rax,%rsi
jne    1c70 <hugeglasso+0xb40>
test   $0x1,%dl
je     14c0 <hugeglasso+0x390>
jmp    1cc5 <hugeglasso+0xb95>
xor    %eax,%eax
mov    0x70(%rsp),%r12
mov    0x18(%rsp),%rdx
test   $0x1,%dl
je     14c0 <hugeglasso+0x390>
movsd  (%r12,%rax,8),%xmm1
add    %rax,%r14
subsd  (%rbx,%r14,8),%xmm1
andpd  %xmm11,%xmm1
addsd  %xmm1,%xmm5
jmp    14c0 <hugeglasso+0x390>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
divsd  %xmm0,%xmm5
ucomisd %xmm9,%xmm5
mov    0xd8(%rsp),%rcx
jbe    1d0f <hugeglasso+0xbdf>
lea    0x1(%rcx),%eax
cmp    $0x63,%ecx
jb     1450 <hugeglasso+0x320>
cmpl   $0x0,0xc(%rsp)
jle    214c <hugeglasso+0x101c>
lea    0x18(%rbx),%r13
lea    0x18(%rbp),%r11
lea    -0x5(%rdx),%rax
mov    %rax,0x68(%rsp)
xor    %esi,%esi
movsd  0x12f2(%rip),%xmm8
movapd 0x12c2(%rip),%xmm1
mov    %rdx,%rdi
mov    $0x1,%r9d
mov    %rbx,%r14
mov    %rbp,%r10
mov    %rbp,0x28(%rsp)
mov    %rbx,%rax
jmp    1d9d <hugeglasso+0xc6d>
nopw   0x0(%rax,%rax,1)
mov    0x30(%rsp),%r9
add    $0x1,%r9
mov    0x60(%rsp),%rcx
add    %rcx,%r13
add    %rcx,%r11
add    %rcx,%rax
add    %rcx,0x28(%rsp)
mov    0xa8(%rsp),%rcx
add    %rcx,%r10
add    %rcx,%r14
add    $0xffffffffffffffff,%rdi
addq   $0xffffffffffffffff,0x68(%rsp)
cmp    %rdx,%rsi
je     214c <hugeglasso+0x101c>
mov    %rdi,0x20(%rsp)
mov    %rsi,%r8
mov    %rsi,%r12
and    $0xfffffffffffffffc,%r12
test   %rsi,%rsi
je     1e60 <hugeglasso+0xd30>
lea    -0x1(%r8),%rcx
xorpd  %xmm2,%xmm2
xor    %edi,%edi
cmp    $0x3,%rcx
jb     1e20 <hugeglasso+0xcf0>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x18(%r11,%rdi,8),%xmm3
movsd  -0x10(%r11,%rdi,8),%xmm4
mulsd  -0x18(%r13,%rdi,8),%xmm3
mulsd  -0x10(%r13,%rdi,8),%xmm4
addsd  %xmm2,%xmm3
movsd  -0x8(%r11,%rdi,8),%xmm5
mulsd  -0x8(%r13,%rdi,8),%xmm5
addsd  %xmm3,%xmm4
movsd  (%r11,%rdi,8),%xmm2
mulsd  0x0(%r13,%rdi,8),%xmm2
addsd  %xmm4,%xmm5
addsd  %xmm5,%xmm2
add    $0x4,%rdi
cmp    %rdi,%r12
jne    1dd0 <hugeglasso+0xca0>
test   $0x3,%r8b
je     1e64 <hugeglasso+0xd34>
mov    %r8d,%ecx
and    $0x3,%ecx
lea    (%rax,%rdi,8),%rdx
mov    0x28(%rsp),%rsi
lea    (%rsi,%rdi,8),%rdi
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rsi,8),%xmm3
mulsd  (%rdx,%rsi,8),%xmm3
addsd  %xmm3,%xmm2
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    1e40 <hugeglasso+0xd10>
jmp    1e64 <hugeglasso+0xd34>
nopl   0x0(%rax)
xorpd  %xmm2,%xmm2
lea    0x1(%r8),%rcx
mov    %rcx,0x40(%rsp)
cmp    0x10(%rsp),%rcx
mov    %r9,0x30(%rsp)
jge    1eb0 <hugeglasso+0xd80>
mov    $0x1,%ecx
mov    0x18(%rsp),%rdx
mov    0x20(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
movsd  (%r10,%rcx,8),%xmm3
mulsd  (%r14,%rcx,8),%xmm3
addsd  %xmm3,%xmm2
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    1e90 <hugeglasso+0xd60>
jmp    1eba <hugeglasso+0xd8a>
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rdx
mov    0x20(%rsp),%rdi
mov    %r8,%rcx
imul   0x10(%rsp),%rcx
mov    %rcx,0x58(%rsp)
mov    %r8d,%ecx
imul   0xc(%rsp),%ecx
movslq %ecx,%rcx
add    %r8,%rcx
movsd  0x0(%rbp,%rcx,8),%xmm3
subsd  %xmm2,%xmm3
movapd %xmm8,%xmm2
divsd  %xmm3,%xmm2
movsd  %xmm2,(%rbx,%rcx,8)
test   %r8,%r8
je     1ff9 <hugeglasso+0xec9>
movapd %xmm2,%xmm3
xorpd  %xmm1,%xmm3
cmp    $0x4,%r8
jae    1f10 <hugeglasso+0xde0>
xor    %r9d,%r9d
jmp    1fe0 <hugeglasso+0xeb0>
nopl   (%rax)
mov    %r8,%r9
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
and    %rcx,%r9
lea    -0x4(%r9),%rsi
mov    %rsi,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
test   %rsi,%rsi
je     213c <hugeglasso+0x100c>
add    $0xfffffffffffffffc,%r12
shr    $0x2,%r12
add    $0x1,%r12
and    $0xfffffffffffffffe,%r12
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%rax,%rdi,8),%xmm5
movupd 0x10(%rax,%rdi,8),%xmm6
movupd 0x20(%rax,%rdi,8),%xmm7
movupd 0x30(%rax,%rdi,8),%xmm0
mulpd  %xmm4,%xmm5
mulpd  %xmm4,%xmm6
movupd %xmm5,(%rax,%rdi,8)
movupd %xmm6,0x10(%rax,%rdi,8)
mulpd  %xmm4,%xmm7
mulpd  %xmm4,%xmm0
movupd %xmm7,0x20(%rax,%rdi,8)
movupd %xmm0,0x30(%rax,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%r12
jne    1f60 <hugeglasso+0xe30>
test   $0x1,%cl
je     1fd0 <hugeglasso+0xea0>
add    0x58(%rsp),%rdi
movupd (%rbx,%rdi,8),%xmm0
movupd 0x10(%rbx,%rdi,8),%xmm5
mulpd  %xmm4,%xmm0
mulpd  %xmm4,%xmm5
movupd %xmm0,(%rbx,%rdi,8)
movupd %xmm5,0x10(%rbx,%rdi,8)
cmp    %r9,%r8
mov    0x20(%rsp),%rdi
je     1ff9 <hugeglasso+0xec9>
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%r9,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rax,%r9,8)
add    $0x1,%r9
cmp    %r9,%r8
jne    1fe0 <hugeglasso+0xeb0>
mov    0x40(%rsp),%rsi
cmp    0x10(%rsp),%rsi
mov    0x70(%rsp),%r12
jge    1d60 <hugeglasso+0xc30>
mov    %r8,%r9
not    %r9
add    %rdx,%r9
xorpd  %xmm1,%xmm2
mov    0x30(%rsp),%rcx
cmp    $0x4,%r9
jb     210f <hugeglasso+0xfdf>
mov    0xa0(%rsp),%rcx
sub    %r8,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,%r8
shr    $0x2,%r8
add    $0x1,%r8
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
cmp    $0x4,%rcx
jae    2056 <hugeglasso+0xf26>
xor    %edi,%edi
jmp    20c2 <hugeglasso+0xf92>
mov    0x68(%rsp),%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %edi,%edi
nopl   0x0(%rax)
movupd 0x8(%r14,%rdi,8),%xmm0
movupd 0x18(%r14,%rdi,8),%xmm4
movupd 0x28(%r14,%rdi,8),%xmm5
movupd 0x38(%r14,%rdi,8),%xmm6
mulpd  %xmm3,%xmm0
mulpd  %xmm3,%xmm4
movupd %xmm0,0x8(%r14,%rdi,8)
movupd %xmm4,0x18(%r14,%rdi,8)
mulpd  %xmm3,%xmm5
mulpd  %xmm3,%xmm6
movupd %xmm5,0x28(%r14,%rdi,8)
movupd %xmm6,0x38(%r14,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rcx
jne    2070 <hugeglasso+0xf40>
mov    %r9,%rcx
and    $0xfffffffffffffffc,%rcx
test   $0x1,%r8b
je     20f7 <hugeglasso+0xfc7>
add    0x30(%rsp),%rdi
add    0x58(%rsp),%rdi
movupd (%rbx,%rdi,8),%xmm0
movupd 0x10(%rbx,%rdi,8),%xmm4
mulpd  %xmm3,%xmm0
mulpd  %xmm3,%xmm4
movupd %xmm0,(%rbx,%rdi,8)
movupd %xmm4,0x10(%rbx,%rdi,8)
cmp    %rcx,%r9
mov    0x20(%rsp),%rdi
mov    0x40(%rsp),%rsi
je     1d60 <hugeglasso+0xc30>
add    0x30(%rsp),%rcx
mov    0x40(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    2120 <hugeglasso+0xff0>
jmp    1d60 <hugeglasso+0xc30>
xor    %edi,%edi
test   $0x1,%cl
jne    1fad <hugeglasso+0xe7d>
jmp    1fd0 <hugeglasso+0xea0>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
mov    0x50(%rsp),%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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