int xx_matrix_jacobi_solve(double *e_vec, double *e_val, int *n_rot,
                           double *input, int size) {
  double stack_A_tmp[5 * 5];
  double stack_b_tmp[5];
  double stack_z_tmp[5];
  double *A_tmp = ((void *)0);
  double *b_tmp = ((void *)0);
  double *z_tmp = ((void *)0);
  int ok = 1;
  if (size > 5) {
    A_tmp = (double *)malloc(sizeof(double) * size * size);
    b_tmp = (double *)malloc(sizeof(double) * size);
    z_tmp = (double *)malloc(sizeof(double) * size);
    if (!(A_tmp && b_tmp && z_tmp))
      ok = 0;
  } else {
    A_tmp = stack_A_tmp;
    b_tmp = stack_b_tmp;
    z_tmp = stack_z_tmp;
  }
  if (ok) {
    memset(e_vec, 0, sizeof(double) * size * size);
    memcpy(A_tmp, input, sizeof(double) * size * size);
    {
      int p;
      for (p = 0; p < size; p++) {
        e_vec[(((p) * (size)) + p)] = 1.0;
        e_val[p] = b_tmp[p] = A_tmp[(((p) * (size)) + p)];
        z_tmp[p] = 0.0;
      }
      *n_rot = 0;
    }
    {
      int i;
      for (i = 0; i < 50; i++) {
        double thresh;
        {
          int p, q;
          double sm = 0.0;
          for (p = 0; p < (size - 1); p++) {
            for (q = p + 1; q < size; q++) {
              sm += fabs(A_tmp[(((p) * (size)) + q)]);
            }
          }
          if (sm == 0.0)
            break;
          if (i < 3) {
            thresh = 0.2 * sm / (size * size);
          } else {
            thresh = 0.0;
          }
        }
        {
          int p, q;
          double g;
          for (p = 0; p < (size - 1); p++) {
            for (q = p + 1; q < size; q++) {
              g = 100.0 * fabs(A_tmp[(((p) * (size)) + q)]);
              if ((i > 3) && ((fabs(e_val[p]) + g) == fabs(e_val[p])) &&
                  ((fabs(e_val[q]) + g) == fabs(e_val[q]))) {
                A_tmp[(((p) * (size)) + q)] = 0.0;
              } else if (fabs(A_tmp[(((p) * (size)) + q)]) > thresh) {
                double t;
                double h = e_val[q] - e_val[p];
                if ((fabs(h) + g) == fabs(h)) {
                  t = A_tmp[(((p) * (size)) + q)] / h;
                } else {
                  double theta = 0.5 * h / A_tmp[(((p) * (size)) + q)];
                  t = 1.0 / (fabs(theta) + sqrt(1.0 + theta * theta));
                  if (theta < 0.0)
                    t = -t;
                }
                {
                  double c = 1.0 / sqrt(1.0 + t * t);
                  double s = t * c;
                  double tau = s / (1.0 + c);
                  h = t * A_tmp[(((p) * (size)) + q)];
                  z_tmp[p] -= h;
                  z_tmp[q] += h;
                  e_val[p] -= h;
                  e_val[q] += h;
                  A_tmp[(((p) * (size)) + q)] = 0.0;
                  {
                    int j;
                    for (j = 0; j < p; j++) {
                      g = A_tmp[(((j) * (size)) + p)];
                      h = A_tmp[(((j) * (size)) + q)];
                      A_tmp[(((j) * (size)) + p)] = g - s * (h + g * tau);
                      A_tmp[(((j) * (size)) + q)] = h + s * (g - h * tau);
                    }
                    for (j = p + 1; j < q; j++) {
                      g = A_tmp[(((p) * (size)) + j)];
                      h = A_tmp[(((j) * (size)) + q)];
                      A_tmp[(((p) * (size)) + j)] = g - s * (h + g * tau);
                      A_tmp[(((j) * (size)) + q)] = h + s * (g - h * tau);
                    }
                    for (j = q + 1; j < size; j++) {
                      g = A_tmp[(((p) * (size)) + j)];
                      h = A_tmp[(((q) * (size)) + j)];
                      A_tmp[(((p) * (size)) + j)] = g - s * (h + g * tau);
                      A_tmp[(((q) * (size)) + j)] = h + s * (g - h * tau);
                    }
                    for (j = 0; j < size; j++) {
                      g = e_vec[(((j) * (size)) + p)];
                      h = e_vec[(((j) * (size)) + q)];
                      e_vec[(((j) * (size)) + p)] = g - s * (h + g * tau);
                      e_vec[(((j) * (size)) + q)] = h + s * (g - h * tau);
                    }
                  }
                  (*n_rot)++;
                }
              }
            }
          }
          for (p = 0; p < size; p++) {
            b_tmp[p] += z_tmp[p];
            e_val[p] = b_tmp[p];
            z_tmp[p] = 0.0;
          }
        }
      }
    }
  }
  if (A_tmp && (A_tmp != stack_A_tmp))
    free(A_tmp);
  if (b_tmp && (b_tmp != stack_b_tmp))
    free(b_tmp);
  if (z_tmp && (z_tmp != stack_z_tmp))
    free(z_tmp);
  return ok;
}


x86 assembly (clang, -O0):
<xx_matrix_jacobi_solve>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1e0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
movq   $0x0,-0x158(%rbp)
movq   $0x0,-0x160(%rbp)
movq   $0x0,-0x168(%rbp)
movl   $0x1,-0x16c(%rbp)
cmpl   $0x5,-0x24(%rbp)
jle    1221 <xx_matrix_jacobi_solve+0xd1>
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
movslq -0x24(%rbp),%rax
imul   %rax,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x158(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x160(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x168(%rbp)
cmpq   $0x0,-0x158(%rbp)
je     1212 <xx_matrix_jacobi_solve+0xc2>
cmpq   $0x0,-0x160(%rbp)
je     1212 <xx_matrix_jacobi_solve+0xc2>
cmpq   $0x0,-0x168(%rbp)
jne    121c <xx_matrix_jacobi_solve+0xcc>
movl   $0x0,-0x16c(%rbp)
jmp    124b <xx_matrix_jacobi_solve+0xfb>
lea    -0xf0(%rbp),%rax
mov    %rax,-0x158(%rbp)
lea    -0x120(%rbp),%rax
mov    %rax,-0x160(%rbp)
lea    -0x150(%rbp),%rax
mov    %rax,-0x168(%rbp)
cmpl   $0x0,-0x16c(%rbp)
je     1efb <xx_matrix_jacobi_solve+0xdab>
mov    -0x8(%rbp),%rdi
movslq -0x24(%rbp),%rdx
shl    $0x3,%rdx
movslq -0x24(%rbp),%rax
imul   %rax,%rdx
xor    %esi,%esi
call   1040 <memset@plt>
mov    -0x158(%rbp),%rdi
mov    -0x20(%rbp),%rsi
movslq -0x24(%rbp),%rdx
shl    $0x3,%rdx
movslq -0x24(%rbp),%rax
imul   %rax,%rdx
call   1050 <memcpy@plt>
movl   $0x0,-0x170(%rbp)
mov    -0x170(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    133c <xx_matrix_jacobi_solve+0x1ec>
mov    -0x8(%rbp),%rax
mov    -0x170(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x170(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xd45(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x158(%rbp),%rax
mov    -0x170(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x170(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x160(%rbp),%rax
movslq -0x170(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x170(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x168(%rbp),%rax
movslq -0x170(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x170(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x170(%rbp)
jmp    129d <xx_matrix_jacobi_solve+0x14d>
mov    -0x18(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x174(%rbp)
cmpl   $0x32,-0x174(%rbp)
jge    1ef6 <xx_matrix_jacobi_solve+0xda6>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movl   $0x0,-0x184(%rbp)
mov    -0x184(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    140b <xx_matrix_jacobi_solve+0x2bb>
mov    -0x184(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x188(%rbp)
mov    -0x188(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    13f2 <xx_matrix_jacobi_solve+0x2a2>
mov    -0x158(%rbp),%rax
mov    -0x184(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x188(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xc56(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x190(%rbp),%xmm0
ff
movsd  %xmm0,-0x190(%rbp)
ff
mov    -0x188(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x188(%rbp)
jmp    1395 <xx_matrix_jacobi_solve+0x245>
jmp    13f7 <xx_matrix_jacobi_solve+0x2a7>
mov    -0x184(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x184(%rbp)
jmp    1372 <xx_matrix_jacobi_solve+0x222>
movsd  -0x190(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    142b <xx_matrix_jacobi_solve+0x2db>
jp     142b <xx_matrix_jacobi_solve+0x2db>
jmp    1ef6 <xx_matrix_jacobi_solve+0xda6>
cmpl   $0x3,-0x174(%rbp)
jge    1464 <xx_matrix_jacobi_solve+0x314>
movsd  0xbc0(%rip),%xmm0
mulsd  -0x190(%rbp),%xmm0
ff
mov    -0x24(%rbp),%eax
imul   -0x24(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
jmp    146f <xx_matrix_jacobi_solve+0x31f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movl   $0x0,-0x194(%rbp)
mov    -0x194(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1e4c <xx_matrix_jacobi_solve+0xcfc>
mov    -0x194(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x198(%rbp)
mov    -0x198(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1e33 <xx_matrix_jacobi_solve+0xce3>
mov    -0x158(%rbp),%rax
mov    -0x194(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x198(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xb4f(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xb2b(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
cmpl   $0x3,-0x174(%rbp)
jle    15b9 <xx_matrix_jacobi_solve+0x469>
mov    -0x10(%rbp),%rax
movslq -0x194(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xb13(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x1a0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x194(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xaf0(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jne    15b9 <xx_matrix_jacobi_solve+0x469>
jp     15b9 <xx_matrix_jacobi_solve+0x469>
mov    -0x10(%rbp),%rax
movslq -0x198(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xac5(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x1a0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x198(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xaa2(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jne    15b9 <xx_matrix_jacobi_solve+0x469>
jp     15b9 <xx_matrix_jacobi_solve+0x469>
mov    -0x158(%rbp),%rax
mov    -0x194(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x198(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1e1a <xx_matrix_jacobi_solve+0xcca>
mov    -0x158(%rbp),%rax
mov    -0x194(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x198(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xa41(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x180(%rbp),%xmm0
ff
jbe    1e15 <xx_matrix_jacobi_solve+0xcc5>
mov    -0x10(%rbp),%rax
movslq -0x198(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x194(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x1b0(%rbp),%xmm0
ff
movaps 0x9f8(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x1a0(%rbp),%xmm0
ff
movsd  -0x1b0(%rbp),%xmm1
ff
movaps 0x9dd(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jne    168b <xx_matrix_jacobi_solve+0x53b>
jp     168b <xx_matrix_jacobi_solve+0x53b>
mov    -0x158(%rbp),%rax
mov    -0x194(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x198(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x1b0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1a8(%rbp)
ff
jmp    175f <xx_matrix_jacobi_solve+0x60f>
movsd  0x985(%rip),%xmm0
mulsd  -0x1b0(%rbp),%xmm0
ff
mov    -0x158(%rbp),%rax
mov    -0x194(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x198(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0x1b8(%rbp),%xmm0
ff
movaps 0x94f(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x1b8(%rbp),%xmm0
ff
movsd  -0x1b8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0x917(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1070 <sqrt@plt>
movsd  -0x1e0(%rbp),%xmm1
ff
addsd  %xmm0,%xmm1
movsd  0x8fa(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x1b8(%rbp),%xmm0
ff
jbe    175a <xx_matrix_jacobi_solve+0x60a>
movsd  -0x1a8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
jmp    175f <xx_matrix_jacobi_solve+0x60f>
movsd  -0x1a8(%rbp),%xmm0
ff
movsd  -0x1a8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0x895(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1070 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x881(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  -0x1a8(%rbp),%xmm0
ff
mulsd  -0x1c0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x1c8(%rbp),%xmm0
ff
movsd  0x84d(%rip),%xmm1
addsd  -0x1c0(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x1a8(%rbp),%xmm0
ff
mov    -0x158(%rbp),%rax
mov    -0x194(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x198(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x1b0(%rbp),%xmm1
ff
mov    -0x168(%rbp),%rax
movslq -0x194(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x1b0(%rbp),%xmm0
ff
mov    -0x168(%rbp),%rax
movslq -0x198(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x1b0(%rbp),%xmm1
ff
mov    -0x10(%rbp),%rax
movslq -0x194(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x1b0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x198(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x158(%rbp),%rax
mov    -0x194(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x198(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x1d4(%rbp)
mov    -0x1d4(%rbp),%eax
cmp    -0x194(%rbp),%eax
jge    1a04 <xx_matrix_jacobi_solve+0x8b4>
mov    -0x158(%rbp),%rax
mov    -0x1d4(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x194(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    -0x1d4(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x198(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x1a0(%rbp),%xmm1
ff
movsd  -0x1c8(%rbp),%xmm0
ff
movsd  -0x1b0(%rbp),%xmm3
ff
movsd  -0x1a0(%rbp),%xmm2
ff
movsd  -0x1d0(%rbp),%xmm4
ff
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x158(%rbp),%rax
mov    -0x1d4(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x194(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x1b0(%rbp),%xmm1
ff
movsd  -0x1c8(%rbp),%xmm0
ff
movsd  -0x1a0(%rbp),%xmm3
ff
movsd  -0x1b0(%rbp),%xmm2
ff
movsd  -0x1d0(%rbp),%xmm4
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x158(%rbp),%rax
mov    -0x1d4(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x198(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d4(%rbp)
jmp    18b4 <xx_matrix_jacobi_solve+0x764>
mov    -0x194(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d4(%rbp)
mov    -0x1d4(%rbp),%eax
cmp    -0x198(%rbp),%eax
jge    1b63 <xx_matrix_jacobi_solve+0xa13>
mov    -0x158(%rbp),%rax
mov    -0x194(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x1d4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    -0x1d4(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x198(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x1a0(%rbp),%xmm1
ff
movsd  -0x1c8(%rbp),%xmm0
ff
movsd  -0x1b0(%rbp),%xmm3
ff
movsd  -0x1a0(%rbp),%xmm2
ff
movsd  -0x1d0(%rbp),%xmm4
ff
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x158(%rbp),%rax
mov    -0x194(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x1d4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x1b0(%rbp),%xmm1
ff
movsd  -0x1c8(%rbp),%xmm0
ff
movsd  -0x1a0(%rbp),%xmm3
ff
movsd  -0x1b0(%rbp),%xmm2
movsd  -0x1d0(%rbp),%xmm4
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x158(%rbp),%rax
mov    -0x1d4(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x198(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d4(%rbp)
jmp    1a13 <xx_matrix_jacobi_solve+0x8c3>
mov    -0x198(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d4(%rbp)
mov    -0x1d4(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1cbf <xx_matrix_jacobi_solve+0xb6f>
mov    -0x158(%rbp),%rax
mov    -0x194(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x1d4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    -0x198(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x1d4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x1a0(%rbp),%xmm1
ff
movsd  -0x1c8(%rbp),%xmm0
ff
movsd  -0x1b0(%rbp),%xmm3
ff
movsd  -0x1a0(%rbp),%xmm2
ff
movsd  -0x1d0(%rbp),%xmm4
ff
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x158(%rbp),%rax
mov    -0x194(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x1d4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x1b0(%rbp),%xmm1
ff
movsd  -0x1c8(%rbp),%xmm0
ff
movsd  -0x1a0(%rbp),%xmm3
ff
movsd  -0x1b0(%rbp),%xmm2
ff
movsd  -0x1d0(%rbp),%xmm4
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x158(%rbp),%rax
mov    -0x198(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x1d4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d4(%rbp)
jmp    1b72 <xx_matrix_jacobi_solve+0xa22>
movl   $0x0,-0x1d4(%rbp)
mov    -0x1d4(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1e0a <xx_matrix_jacobi_solve+0xcba>
mov    -0x8(%rbp),%rax
mov    -0x1d4(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x194(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x1d4(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x198(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x1a0(%rbp),%xmm1
ff
movsd  -0x1c8(%rbp),%xmm0
ff
movsd  -0x1b0(%rbp),%xmm3
ff
movsd  -0x1a0(%rbp),%xmm2
ff
movsd  -0x1d0(%rbp),%xmm4
ff
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1d4(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x194(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x1b0(%rbp),%xmm1
ff
movsd  -0x1c8(%rbp),%xmm0
ff
movsd  -0x1a0(%rbp),%xmm3
ff
movsd  -0x1b0(%rbp),%xmm2
ff
movsd  -0x1d0(%rbp),%xmm4
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1d4(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x198(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d4(%rbp)
jmp    1cc9 <xx_matrix_jacobi_solve+0xb79>
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    1e1a <xx_matrix_jacobi_solve+0xcca>
jmp    1e1f <xx_matrix_jacobi_solve+0xccf>
mov    -0x198(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x198(%rbp)
jmp    149c <xx_matrix_jacobi_solve+0x34c>
jmp    1e38 <xx_matrix_jacobi_solve+0xce8>
mov    -0x194(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x194(%rbp)
jmp    1479 <xx_matrix_jacobi_solve+0x329>
movl   $0x0,-0x194(%rbp)
mov    -0x194(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1edd <xx_matrix_jacobi_solve+0xd8d>
mov    -0x168(%rbp),%rax
movslq -0x194(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x160(%rbp),%rax
movslq -0x194(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x160(%rbp),%rax
movslq -0x194(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x194(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x168(%rbp),%rax
movslq -0x194(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x194(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x194(%rbp)
jmp    1e56 <xx_matrix_jacobi_solve+0xd06>
jmp    1ee2 <xx_matrix_jacobi_solve+0xd92>
mov    -0x174(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x174(%rbp)
jmp    1350 <xx_matrix_jacobi_solve+0x200>
jmp    1efb <xx_matrix_jacobi_solve+0xdab>
cmpq   $0x0,-0x158(%rbp)
je     1f2c <xx_matrix_jacobi_solve+0xddc>
mov    -0x158(%rbp),%rax
lea    -0xf0(%rbp),%rcx
cmp    %rcx,%rax
je     1f2c <xx_matrix_jacobi_solve+0xddc>
mov    -0x158(%rbp),%rdi
call   1030 <free@plt>
cmpq   $0x0,-0x160(%rbp)
je     1f5d <xx_matrix_jacobi_solve+0xe0d>
mov    -0x160(%rbp),%rax
lea    -0x120(%rbp),%rcx
cmp    %rcx,%rax
je     1f5d <xx_matrix_jacobi_solve+0xe0d>
mov    -0x160(%rbp),%rdi
call   1030 <free@plt>
cmpq   $0x0,-0x168(%rbp)
je     1f8e <xx_matrix_jacobi_solve+0xe3e>
mov    -0x168(%rbp),%rax
lea    -0x150(%rbp),%rcx
cmp    %rcx,%rax
je     1f8e <xx_matrix_jacobi_solve+0xe3e>
mov    -0x168(%rbp),%rdi
call   1030 <free@plt>
mov    -0x16c(%rbp),%eax
add    $0x1e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<xx_matrix_jacobi_solve>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2b8,%rsp
mov    %rcx,%r14
mov    %rdx,0xe0(%rsp)
mov    %rsi,0x18(%rsp)
mov    %rdi,%r12
mov    %r8d,%eax
cmp    $0x5,%r8d
mov    %r8,0x8(%rsp)
mov    %rax,0x20(%rsp)
jle    11e5 <xx_matrix_jacobi_solve+0x95>
lea    0x0(,%rax,8),%r15
mov    %r15,%rdi
imul   %rax,%rdi
call   1060 <malloc@plt>
mov    %rax,%rbp
mov    %r15,%rdi
call   1060 <malloc@plt>
mov    %rax,%rbx
mov    %r15,%rdi
call   1060 <malloc@plt>
mov    %rax,0x10(%rsp)
movl   $0x0,0x58(%rsp)
mov    %rbp,%rdi
test   %rbp,%rbp
je     1e8b <xx_matrix_jacobi_solve+0xd3b>
test   %rbx,%rbx
je     1e8b <xx_matrix_jacobi_solve+0xd3b>
cmpq   $0x0,0x10(%rsp)
mov    0x8(%rsp),%r8
jne    1202 <xx_matrix_jacobi_solve+0xb2>
jmp    1e8b <xx_matrix_jacobi_solve+0xd3b>
lea    0x1f0(%rsp),%rdi
lea    0x1c0(%rsp),%rbx
lea    0x190(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    %rdi,0x28(%rsp)
movslq %r8d,%rbp
mov    %rbp,0x38(%rsp)
imul   %rbp,%rbp
shl    $0x3,%rbp
mov    %r12,%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1040 <memset@plt>
mov    0x28(%rsp),%rdi
mov    %r14,%rsi
mov    %rbp,%rdx
call   1050 <memcpy@plt>
mov    0x28(%rsp),%r11
cmpl   $0x0,0x8(%rsp)
jle    1319 <xx_matrix_jacobi_solve+0x1c9>
mov    0x20(%rsp),%rbp
lea    0x0(,%rbp,8),%rdx
xor    %r14d,%r14d
mov    0x10(%rsp),%rdi
xor    %esi,%esi
call   1040 <memset@plt>
movabs $0x3ff0000000000000,%r8
cmpl   $0x1,0x8(%rsp)
jne    127a <xx_matrix_jacobi_solve+0x12a>
xor    %ecx,%ecx
mov    0x28(%rsp),%r11
jmp    12ed <xx_matrix_jacobi_solve+0x19d>
mov    %ebp,%r9d
and    $0xfffffffe,%r9d
mov    0x8(%rsp),%rbp
lea    0x0(%rbp,%rbp,1),%r10d
mov    $0x1,%esi
xor    %ecx,%ecx
mov    0x28(%rsp),%r11
mov    0x18(%rsp),%r15
nopl   0x0(%rax)
movslq %ebp,%rbp
lea    (%rsi,%rbp,1),%rax
movslq %r14d,%r14
lea    (%rcx,%r14,1),%rdx
mov    %r8,(%r12,%rdx,8)
movsd  (%r11,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
movsd  %xmm0,(%r15,%rcx,8)
mov    %r8,(%r12,%rax,8)
movsd  (%r11,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rcx,8)
movsd  %xmm0,0x8(%r15,%rcx,8)
add    $0x2,%rcx
add    %r10d,%r14d
add    $0x2,%rsi
add    %r10d,%ebp
cmp    %rcx,%r9
jne    12a0 <xx_matrix_jacobi_solve+0x150>
testb  $0x1,0x20(%rsp)
je     1319 <xx_matrix_jacobi_solve+0x1c9>
mov    %ecx,%eax
imul   0x8(%rsp),%eax
cltq
add    %rcx,%rax
mov    %r8,(%r12,%rax,8)
movsd  (%r11,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
mov    0x18(%rsp),%rax
movsd  %xmm0,(%rax,%rcx,8)
mov    %r12,0x180(%rsp)
mov    0xe0(%rsp),%rax
movl   $0x0,(%rax)
mov    0x8(%rsp),%rax
lea    -0x1(%rax),%ebp
imul   %eax,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x150(%rsp)
mov    0x38(%rsp),%r8
lea    0x0(,%r8,8),%r12
lea    0x8(,%r8,8),%rax
mov    %rax,0x50(%rsp)
lea    0x10(%r11,%r8,8),%rax
mov    %rax,0x88(%rsp)
lea    (%r8,%r8,1),%rax
mov    %rax,0x160(%rsp)
lea    -0x2(%r8),%rax
mov    %rax,0xc8(%rsp)
mov    0x20(%rsp),%rax
and    $0xfffffffc,%eax
mov    %rax,0x128(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x120(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x118(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x110(%rsp)
lea    (%r11,%r8,8),%rax
add    $0x8,%rax
mov    %rax,0x148(%rsp)
lea    0x8(%r11),%rax
mov    %rax,0x140(%rsp)
lea    0x10(%r11),%rax
mov    %rax,0x138(%rsp)
lea    (%r11,%r8,8),%rax
mov    %rax,0x130(%rsp)
movapd 0xbfc(%rip),%xmm9
xorpd  %xmm10,%xmm10
movsd  0xc16(%rip),%xmm11
movsd  0xc1d(%rip),%xmm12
movapd 0xbec(%rip),%xmm13
xor    %r9d,%r9d
mov    %rbx,0x158(%rsp)
mov    %rbp,0x168(%rsp)
jmp    144e <xx_matrix_jacobi_solve+0x2fe>
nopl   0x0(%rax)
add    $0x1,%r9d
cmp    $0x32,%r9d
je     1e88 <xx_matrix_jacobi_solve+0xd38>
movl   $0x1,0x58(%rsp)
cmpl   $0x2,0x8(%rsp)
jl     1e88 <xx_matrix_jacobi_solve+0xd38>
mov    %r9,0xe8(%rsp)
xorpd  %xmm0,%xmm0
mov    0x20(%rsp),%rax
mov    %r11,%rcx
xor    %edx,%edx
jmp    1493 <xx_matrix_jacobi_solve+0x343>
nopl   0x0(%rax)
add    0x50(%rsp),%rcx
add    $0xffffffffffffffff,%rax
cmp    %rbp,%rdx
mov    0x38(%rsp),%r8
je     14d0 <xx_matrix_jacobi_solve+0x380>
add    $0x1,%rdx
cmp    %r8,%rdx
jge    1480 <xx_matrix_jacobi_solve+0x330>
mov    $0x1,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rsi,8),%xmm1
andpd  %xmm9,%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rsi
cmp    %rsi,%rax
jne    14b0 <xx_matrix_jacobi_solve+0x360>
jmp    1480 <xx_matrix_jacobi_solve+0x330>
nopl   0x0(%rax)
ucomisd %xmm10,%xmm0
jne    14dd <xx_matrix_jacobi_solve+0x38d>
jnp    1e88 <xx_matrix_jacobi_solve+0xd38>
xorpd  %xmm14,%xmm14
mov    0xe8(%rsp),%r9
cmp    $0x2,%r9d
ja     1506 <xx_matrix_jacobi_solve+0x3b6>
mulsd  0xb28(%rip),%xmm0
divsd  0x150(%rsp),%xmm0
movapd %xmm0,%xmm14
cmpl   $0x2,0x8(%rsp)
jl     1ce0 <xx_matrix_jacobi_solve+0xb90>
mov    $0x1,%eax
mov    %rax,0xc0(%rsp)
movl   $0x2,0x5c(%rsp)
mov    $0x8,%eax
mov    %rax,0xb8(%rsp)
mov    0x130(%rsp),%rax
mov    %rax,0xb0(%rsp)
mov    %r11,0x40(%rsp)
mov    0x88(%rsp),%rax
mov    %rax,0xa8(%rsp)
mov    0x138(%rsp),%rax
mov    %rax,0xa0(%rsp)
mov    0xc8(%rsp),%rax
mov    %rax,0x98(%rsp)
mov    0x140(%rsp),%r15
mov    0x148(%rsp),%rax
mov    %rax,0x90(%rsp)
xor    %r14d,%r14d
xor    %eax,%eax
movsd  %xmm14,0xd8(%rsp)
jmp    161a <xx_matrix_jacobi_solve+0x4ca>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addq   $0x1,0xc0(%rsp)
addl   $0x1,0x5c(%rsp)
addq   $0x8,0xb8(%rsp)
add    $0x8,%r14
mov    0x50(%rsp),%rax
add    %rax,0x90(%rsp)
add    %rax,%r15
addq   $0xffffffffffffffff,0x98(%rsp)
add    %rax,0xa0(%rsp)
add    %rax,0xa8(%rsp)
add    %r12,0x40(%rsp)
add    %r12,0xb0(%rsp)
mov    0x168(%rsp),%rbp
mov    0xf0(%rsp),%rax
cmp    %rbp,%rax
je     1ce0 <xx_matrix_jacobi_solve+0xb90>
mov    %rax,%rcx
mov    %rax,0x30(%rsp)
add    $0x1,%rax
mov    %rax,0xf0(%rsp)
cmp    %r8,%rax
jge    15b0 <xx_matrix_jacobi_solve+0x460>
mov    0x50(%rsp),%rcx
mov    0x30(%rsp),%rax
imul   %rax,%rcx
mov    %rcx,0xd0(%rsp)
mov    %rax,%rcx
imul   %r8,%rcx
lea    (%rcx,%r8,1),%rax
lea    (%r11,%rax,8),%rax
mov    %rax,0x170(%rsp)
mov    0x160(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x178(%rsp)
movslq 0x5c(%rsp),%rax
mov    %rax,0x78(%rsp)
mov    0xb0(%rsp),%rbp
mov    0xa8(%rsp),%rax
mov    0xa0(%rsp),%rdx
mov    0x98(%rsp),%r10
mov    0x90(%rsp),%rsi
mov    0xb8(%rsp),%r13
xor    %ebx,%ebx
mov    0xc0(%rsp),%rdi
mov    %rcx,0x188(%rsp)
jmp    1721 <xx_matrix_jacobi_solve+0x5d1>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0xe0(%rsp),%rax
addl   $0x1,(%rax)
mov    0xe8(%rsp),%r9
mov    0x70(%rsp),%rax
mov    0xf8(%rsp),%rdx
add    $0x1,%rdi
addq   $0x1,0x78(%rsp)
add    $0x1,%rbx
add    $0x8,%r13
add    $0x8,%rsi
add    $0xffffffffffffffff,%r10
add    $0x8,%rdx
add    0x50(%rsp),%rax
add    %r12,%rbp
cmp    0x20(%rsp),%rdi
je     15b0 <xx_matrix_jacobi_solve+0x460>
mov    0x188(%rsp),%rcx
add    %rdi,%rcx
mov    %rcx,0x80(%rsp)
movsd  (%r11,%rcx,8),%xmm4
movapd %xmm4,%xmm1
andpd  %xmm9,%xmm1
movapd %xmm1,%xmm0
mulsd  %xmm11,%xmm0
cmp    $0x4,%r9d
jb     17e0 <xx_matrix_jacobi_solve+0x690>
mov    %rbx,0x70(%rsp)
mov    %r15,%rbx
mov    %r9,%r15
mov    %rdi,%r9
mov    %rdx,%rdi
mov    %rax,%rdx
mov    0x30(%rsp),%rax
mov    %r8,%rcx
mov    0x18(%rsp),%r8
movsd  (%r8,%rax,8),%xmm2
mov    %rcx,%r8
mov    %rdx,%rax
mov    %rdi,%rdx
mov    %r9,%rdi
mov    %r15,%r9
mov    %rbx,%r15
mov    0x70(%rsp),%rbx
andpd  %xmm9,%xmm2
movapd %xmm0,%xmm3
addsd  %xmm2,%xmm3
ucomisd %xmm2,%xmm3
jne    17e0 <xx_matrix_jacobi_solve+0x690>
jp     17e0 <xx_matrix_jacobi_solve+0x690>
mov    0x18(%rsp),%rcx
movsd  (%rcx,%rdi,8),%xmm2
andpd  %xmm9,%xmm2
movapd %xmm0,%xmm3
addsd  %xmm2,%xmm3
ucomisd %xmm2,%xmm3
jne    17e0 <xx_matrix_jacobi_solve+0x690>
jp     17e0 <xx_matrix_jacobi_solve+0x690>
mov    0x80(%rsp),%rcx
movq   $0x0,(%r11,%rcx,8)
jmp    16f0 <xx_matrix_jacobi_solve+0x5a0>
nopl   (%rax)
ucomisd %xmm14,%xmm1
jbe    16f0 <xx_matrix_jacobi_solve+0x5a0>
mov    %rax,0x70(%rsp)
mov    0x18(%rsp),%rcx
movsd  (%rcx,%rdi,8),%xmm2
mov    0x30(%rsp),%rax
subsd  (%rcx,%rax,8),%xmm2
movapd %xmm2,%xmm1
andpd  %xmm9,%xmm1
addsd  %xmm1,%xmm0
ucomisd %xmm1,%xmm0
mov    %rdx,0xf8(%rsp)
mov    %r10,0x68(%rsp)
mov    %rdi,0x60(%rsp)
jne    1834 <xx_matrix_jacobi_solve+0x6e4>
jp     1834 <xx_matrix_jacobi_solve+0x6e4>
divsd  %xmm2,%xmm4
jmp    18f3 <xx_matrix_jacobi_solve+0x7a3>
mulsd  0x7f4(%rip),%xmm2
divsd  %xmm4,%xmm2
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm12,%xmm0
ucomisd %xmm10,%xmm0
jb     185a <xx_matrix_jacobi_solve+0x70a>
sqrtsd %xmm0,%xmm0
jmp    18c2 <xx_matrix_jacobi_solve+0x772>
mov    %rsi,0x48(%rsp)
movapd %xmm2,0x100(%rsp)
call   1070 <sqrt@plt>
movapd 0x100(%rsp),%xmm2
mov    0x60(%rsp),%rdi
mov    0x48(%rsp),%rsi
mov    0x68(%rsp),%r10
movsd  0xd8(%rsp),%xmm14
movapd 0x778(%rip),%xmm13
movsd  0x797(%rip),%xmm12
movsd  0x77e(%rip),%xmm11
xorpd  %xmm10,%xmm10
movapd 0x748(%rip),%xmm9
mov    0x38(%rsp),%r8
mov    0x28(%rsp),%r11
movapd %xmm2,%xmm1
andpd  %xmm9,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm12,%xmm4
divsd  %xmm1,%xmm4
cmpltsd %xmm10,%xmm2
movapd %xmm2,%xmm0
andnpd %xmm4,%xmm0
xorpd  %xmm13,%xmm4
andpd  %xmm2,%xmm4
orpd   %xmm0,%xmm4
movapd %xmm4,%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm12,%xmm0
ucomisd %xmm10,%xmm0
jb     1910 <xx_matrix_jacobi_solve+0x7c0>
sqrtsd %xmm0,%xmm0
jmp    1978 <xx_matrix_jacobi_solve+0x828>
nopl   (%rax)
mov    %rsi,0x48(%rsp)
movapd %xmm4,0x100(%rsp)
call   1070 <sqrt@plt>
movapd 0x100(%rsp),%xmm4
mov    0x60(%rsp),%rdi
mov    0x48(%rsp),%rsi
mov    0x68(%rsp),%r10
movsd  0xd8(%rsp),%xmm14
movapd 0x6c2(%rip),%xmm13
movsd  0x6e1(%rip),%xmm12
movsd  0x6c8(%rip),%xmm11
xorpd  %xmm10,%xmm10
movapd 0x692(%rip),%xmm9
mov    0x38(%rsp),%r8
mov    0x28(%rsp),%r11
mov    0x40(%rsp),%rdx
mov    0x80(%rsp),%r9
movapd %xmm12,%xmm2
divsd  %xmm0,%xmm2
movapd %xmm4,%xmm0
mulsd  %xmm2,%xmm0
mulsd  (%r11,%r9,8),%xmm4
addsd  %xmm12,%xmm2
mov    0x30(%rsp),%rax
mov    0x10(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm1
subsd  %xmm4,%xmm1
movsd  %xmm1,(%rcx,%rax,8)
movsd  (%rcx,%rdi,8),%xmm1
addsd  %xmm4,%xmm1
movsd  %xmm1,(%rcx,%rdi,8)
mov    0x18(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm1
subsd  %xmm4,%xmm1
movsd  %xmm1,(%rcx,%rax,8)
movapd %xmm0,%xmm1
addsd  (%rcx,%rdi,8),%xmm4
divsd  %xmm2,%xmm1
movsd  %xmm4,(%rcx,%rdi,8)
movq   $0x0,(%r11,%r9,8)
test   %rax,%rax
je     1a59 <xx_matrix_jacobi_solve+0x909>
movapd %xmm0,%xmm2
xorpd  %xmm13,%xmm2
mov    0x30(%rsp),%rax
mov    %r11,%rcx
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%r14,1),%xmm3
movsd  (%rcx,%r13,1),%xmm4
movapd %xmm3,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm3,%xmm5
movsd  %xmm5,(%rcx,%r14,1)
movapd %xmm4,%xmm5
mulsd  %xmm1,%xmm5
subsd  %xmm5,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,(%rcx,%r13,1)
add    %r12,%rcx
add    $0xffffffffffffffff,%rax
jne    1a10 <xx_matrix_jacobi_solve+0x8c0>
cmp    %rdi,0xf0(%rsp)
jae    1ac8 <xx_matrix_jacobi_solve+0x978>
movapd %xmm0,%xmm2
xorpd  %xmm13,%xmm2
xor    %eax,%eax
mov    %rsi,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm3
movsd  (%rcx),%xmm4
movapd %xmm3,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm3,%xmm5
movsd  %xmm5,(%r15,%rax,8)
movapd %xmm4,%xmm5
mulsd  %xmm1,%xmm5
subsd  %xmm5,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,(%rcx)
add    %r12,%rcx
add    $0x1,%rax
cmp    %rax,%rbx
jne    1a80 <xx_matrix_jacobi_solve+0x930>
lea    0x1(%rdi),%rax
cmp    %r8,%rax
jge    1c67 <xx_matrix_jacobi_solve+0xb17>
mov    0x30(%rsp),%rax
add    %rbx,%rax
mov    0xc8(%rsp),%rcx
sub    %rax,%rcx
movapd %xmm0,%xmm2
xorpd  %xmm13,%xmm2
mov    0x78(%rsp),%rax
cmp    $0x2,%rcx
jb     1c20 <xx_matrix_jacobi_solve+0xad0>
mov    %rbx,%rax
imul   %r8,%rax
add    0x178(%rsp),%rax
lea    (%r11,%rbx,8),%rdx
mov    %r11,%r9
mov    0xd0(%rsp),%r11
add    %r11,%rdx
add    $0x10,%rdx
mov    0x60(%rsp),%rdi
mov    0x68(%rsp),%r10
lea    (%r9,%rax,8),%rax
cmp    %rax,%rdx
jae    1b6c <xx_matrix_jacobi_solve+0xa1c>
mov    %r9,%r11
mov    0x50(%rsp),%rdx
imul   %rbx,%rdx
add    0xd0(%rsp),%rdx
add    0x88(%rsp),%rdx
mov    0x78(%rsp),%rax
cmp    0x170(%rsp),%rdx
mov    0x40(%rsp),%rdx
jb     1c20 <xx_matrix_jacobi_solve+0xad0>
mov    %rsi,0x48(%rsp)
mov    %r10,%rdx
and    $0xfffffffffffffffe,%rdx
mov    %rcx,%rdi
and    $0xfffffffffffffffe,%rdi
mov    0x78(%rsp),%rax
add    %rdi,%rax
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
movapd %xmm2,%xmm8
unpcklpd %xmm2,%xmm8
movapd %xmm0,%xmm5
unpcklpd %xmm0,%xmm5
xor    %esi,%esi
mov    0x70(%rsp),%r11
mov    0xf8(%rsp),%r10
movupd (%r10,%rsi,8),%xmm4
movupd (%r11,%rsi,8),%xmm7
movapd %xmm4,%xmm6
mulpd  %xmm3,%xmm6
addpd  %xmm7,%xmm6
mulpd  %xmm8,%xmm6
addpd  %xmm4,%xmm6
movupd %xmm6,(%r10,%rsi,8)
movapd %xmm7,%xmm6
mulpd  %xmm3,%xmm6
subpd  %xmm6,%xmm4
mulpd  %xmm5,%xmm4
addpd  %xmm7,%xmm4
movupd %xmm4,(%r11,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rdx
jne    1bb0 <xx_matrix_jacobi_solve+0xa60>
cmp    %rdi,%rcx
mov    0x38(%rsp),%r8
mov    0x40(%rsp),%rdx
mov    0x68(%rsp),%r10
mov    0x48(%rsp),%rsi
mov    0x28(%rsp),%r11
mov    0x60(%rsp),%rdi
je     1c67 <xx_matrix_jacobi_solve+0xb17>
nopl   (%rax)
movsd  (%rdx,%rax,8),%xmm3
movsd  0x0(%rbp,%rax,8),%xmm4
movapd %xmm3,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm3,%xmm5
movsd  %xmm5,(%rdx,%rax,8)
movapd %xmm4,%xmm5
mulsd  %xmm1,%xmm5
subsd  %xmm5,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %r8,%rax
jl     1c20 <xx_matrix_jacobi_solve+0xad0>
cmpl   $0x0,0x8(%rsp)
jle    16d0 <xx_matrix_jacobi_solve+0x580>
movapd %xmm0,%xmm2
xorpd  %xmm13,%xmm2
mov    0x20(%rsp),%rax
mov    0x180(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%r14,1),%xmm3
movsd  (%rcx,%r13,1),%xmm4
movapd %xmm3,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm3,%xmm5
movsd  %xmm5,(%rcx,%r14,1)
movapd %xmm4,%xmm5
mulsd  %xmm1,%xmm5
subsd  %xmm5,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,(%rcx,%r13,1)
add    %r12,%rcx
add    $0xffffffffffffffff,%rax
jne    1c90 <xx_matrix_jacobi_solve+0xb40>
jmp    16d0 <xx_matrix_jacobi_solve+0x580>
xchg   %ax,%ax
cmpl   $0x0,0x8(%rsp)
mov    0x158(%rsp),%rbx
jle    1440 <xx_matrix_jacobi_solve+0x2f0>
cmpl   $0x4,0x8(%rsp)
jae    1d10 <xx_matrix_jacobi_solve+0xbc0>
xor    %eax,%eax
jmp    1e40 <xx_matrix_jacobi_solve+0xcf0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmpq   $0x0,0x120(%rsp)
je     1e76 <xx_matrix_jacobi_solve+0xd26>
mov    0x110(%rsp),%rcx
xor    %eax,%eax
xorpd  %xmm3,%xmm3
nopl   (%rax)
mov    0x10(%rsp),%rdx
movupd (%rdx,%rax,8),%xmm0
movupd 0x10(%rdx,%rax,8),%xmm1
movupd (%rbx,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%rax,8)
movupd %xmm0,0x10(%rbx,%rax,8)
mov    0x18(%rsp),%rsi
movupd %xmm2,(%rsi,%rax,8)
movupd %xmm0,0x10(%rsi,%rax,8)
movupd %xmm3,(%rdx,%rax,8)
movupd %xmm3,0x10(%rdx,%rax,8)
movupd 0x20(%rdx,%rax,8),%xmm0
movupd 0x30(%rdx,%rax,8),%xmm1
movupd 0x20(%rbx,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x30(%rbx,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,0x20(%rbx,%rax,8)
movupd %xmm0,0x30(%rbx,%rax,8)
movupd %xmm2,0x20(%rsi,%rax,8)
movupd %xmm0,0x30(%rsi,%rax,8)
movupd %xmm3,0x20(%rdx,%rax,8)
movupd %xmm3,0x30(%rdx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1d30 <xx_matrix_jacobi_solve+0xbe0>
testb  $0x1,0x118(%rsp)
01
je     1e22 <xx_matrix_jacobi_solve+0xcd2>
mov    0x10(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm0
movupd 0x10(%rcx,%rax,8),%xmm1
movupd (%rbx,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%rax,8)
movupd %xmm0,0x10(%rbx,%rax,8)
mov    0x18(%rsp),%rdx
movupd %xmm2,(%rdx,%rax,8)
movupd %xmm0,0x10(%rdx,%rax,8)
xorpd  %xmm0,%xmm0
movupd %xmm0,(%rcx,%rax,8)
movupd %xmm0,0x10(%rcx,%rax,8)
mov    0x128(%rsp),%rcx
mov    %rcx,%rax
cmp    0x20(%rsp),%rcx
je     1440 <xx_matrix_jacobi_solve+0x2f0>
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
mov    0x18(%rsp),%rdx
movsd  %xmm0,(%rdx,%rax,8)
movq   $0x0,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,0x20(%rsp)
jne    1e40 <xx_matrix_jacobi_solve+0xcf0>
jmp    1440 <xx_matrix_jacobi_solve+0x2f0>
xor    %eax,%eax
testb  $0x1,0x118(%rsp)
01
jne    1dd5 <xx_matrix_jacobi_solve+0xc85>
jmp    1e22 <xx_matrix_jacobi_solve+0xcd2>
mov    %r11,%rdi
test   %rdi,%rdi
je     1ea2 <xx_matrix_jacobi_solve+0xd52>
lea    0x1f0(%rsp),%rax
cmp    %rax,%rdi
je     1ea2 <xx_matrix_jacobi_solve+0xd52>
call   1030 <free@plt>
test   %rbx,%rbx
je     1ebc <xx_matrix_jacobi_solve+0xd6c>
lea    0x1c0(%rsp),%rax
cmp    %rax,%rbx
je     1ebc <xx_matrix_jacobi_solve+0xd6c>
mov    %rbx,%rdi
call   1030 <free@plt>
cmpq   $0x0,0x10(%rsp)
je     1edd <xx_matrix_jacobi_solve+0xd8d>
lea    0x190(%rsp),%rax
cmp    %rax,0x10(%rsp)
je     1edd <xx_matrix_jacobi_solve+0xd8d>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    0x58(%rsp),%eax
add    $0x2b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @xx_matrix_jacobi_solve(double* nocapture %0, double* nocapture %1, i32* nocapture %2, double* nocapture %3, i32 %4) {
%6 = alloca [25 x double]
%7 = alloca [5 x double]
%8 = alloca [5 x double]
%9 = bitcast [25 x double]* %6 to i8*
%10 = bitcast [5 x double]* %7 to i8*
%11 = bitcast [5 x double]* %8 to i8*
%12 = icmp sgt i32 %4, 5
br i1 %12, label %17, label %13
13: ; preds = %5
%14 = getelementptr inbounds [25 x double], [25 x double]* %6, i64 0, i64 0
%15 = getelementptr inbounds [5 x double], [5 x double]* %7, i64 0, i64 0
%16 = getelementptr inbounds [5 x double], [5 x double]* %8, i64 0, i64 0
br label %32
17: ; preds = %5
%18 = zext i32 %4 to i64
%19 = shl nuw nsw i64 %18, 3
%20 = mul i64 %19, %18
%21 = tail call i8* @malloc(i64 %20)
%22 = bitcast i8* %21 to double*
%23 = tail call i8* @malloc(i64 %19)
%24 = bitcast i8* %23 to double*
%25 = tail call i8* @malloc(i64 %19)
%26 = bitcast i8* %25 to double*
%27 = icmp ne i8* %21, null
%28 = icmp ne i8* %23, null
%29 = and i1 %27, %28
%30 = icmp ne i8* %25, null
%31 = and i1 %29, %30
br i1 %31, label %32, label %469
32: ; preds = %13, %17
%33 = phi double* [ %14, %13 ], [ %22, %17 ]
%34 = phi double* [ %15, %13 ], [ %24, %17 ]
%35 = phi double* [ %16, %13 ], [ %26, %17 ]
%36 = bitcast double* %0 to i8*
%37 = sext i32 %4 to i64
%38 = shl nsw i64 %37, 3
%39 = mul i64 %38, %37
tail call void @llvm.memset.p0i8.i64(i8* align 8 %36, i8 0, i64 %39, i1 false)
%40 = bitcast double* %33 to i8*
%41 = bitcast double* %3 to i8*
%42 = icmp sgt i32 %4, 0
br i1 %42, label %43, label %89
43: ; preds = %32
%44 = bitcast double* %35 to i8*
%45 = zext i32 %4 to i64
%46 = shl nuw nsw i64 %45, 3
%47 = and i64 %45, 1
%48 = icmp eq i32 %4, 1
br i1 %48, label %76, label %49
49: ; preds = %43
%50 = and i64 %45, 4294967294
br label %51
51: ; preds = %51, %49
%52 = phi i64 [ 0, %49 ], [ %73, %51 ]
%53 = phi i64 [ 0, %49 ], [ %74, %51 ]
%54 = trunc i64 %52 to i32
%55 = mul nsw i32 %54, %4
%56 = sext i32 %55 to i64
%57 = add nsw i64 %52, %56
%58 = getelementptr inbounds double, double* %0, i64 %57
store double 1.000000e+00, double* %58
%59 = getelementptr inbounds double, double* %33, i64 %57
%60 = load double, double* %59
%61 = getelementptr inbounds double, double* %34, i64 %52
store double %60, double* %61
%62 = getelementptr inbounds double, double* %1, i64 %52
store double %60, double* %62
%63 = or i64 %52, 1
%64 = trunc i64 %63 to i32
%65 = mul nsw i32 %64, %4
%66 = sext i32 %65 to i64
%67 = add nsw i64 %63, %66
%68 = getelementptr inbounds double, double* %0, i64 %67
store double 1.000000e+00, double* %68
%69 = getelementptr inbounds double, double* %33, i64 %67
%70 = load double, double* %69
%71 = getelementptr inbounds double, double* %34, i64 %63
store double %70, double* %71
%72 = getelementptr inbounds double, double* %1, i64 %63
store double %70, double* %72
%73 = add nuw nsw i64 %52, 2
%74 = add i64 %53, 2
%75 = icmp eq i64 %74, %50
br i1 %75, label %76, label %51
76: ; preds = %51, %43
%77 = phi i64 [ 0, %43 ], [ %73, %51 ]
%78 = icmp eq i64 %47, 0
br i1 %78, label %89, label %79
79: ; preds = %76
%80 = trunc i64 %77 to i32
%81 = mul nsw i32 %80, %4
%82 = sext i32 %81 to i64
%83 = add nsw i64 %77, %82
%84 = getelementptr inbounds double, double* %0, i64 %83
store double 1.000000e+00, double* %84
%85 = getelementptr inbounds double, double* %33, i64 %83
%86 = load double, double* %85
%87 = getelementptr inbounds double, double* %34, i64 %77
store double %86, double* %87
%88 = getelementptr inbounds double, double* %1, i64 %77
store double %86, double* %88
br label %89
89: ; preds = %79, %76, %32
store i32 0, i32* %2
%90 = add i32 %4, -1
%91 = icmp sgt i32 %4, 1
%92 = mul nsw i32 %4, %4
%93 = sitofp i32 %92 to double
%94 = zext i32 %90 to i64
%95 = zext i32 %4 to i64
%96 = zext i32 %90 to i64
%97 = zext i32 %4 to i64
%98 = zext i32 %4 to i64
%99 = shl nsw i64 %37, 3
%100 = add nsw i64 %99, 8
%101 = add nsw i64 %37, 2
%102 = getelementptr double, double* %33, i64 %101
%103 = bitcast double* %102 to i8*
%104 = shl nsw i64 %37, 1
%105 = add nsw i64 %37, -2
%106 = and i64 %97, 4294967292
%107 = add nsw i64 %106, -4
%108 = lshr exact i64 %107, 2
%109 = add nuw nsw i64 %108, 1
%110 = icmp ult i32 %4, 4
%111 = and i64 %95, 4294967292
%112 = and i64 %109, 1
%113 = icmp eq i64 %107, 0
%114 = and i64 %109, 9223372036854775806
%115 = icmp eq i64 %112, 0
%116 = icmp eq i64 %111, %95
br label %117
117: ; preds = %89, %466
%118 = phi i32 [ 0, %89 ], [ %467, %466 ]
br i1 %91, label %123, label %469
119: ; preds = %131, %123
%120 = phi double [ %126, %123 ], [ %138, %131 ]
%121 = add nuw nsw i64 %125, 1
%122 = icmp eq i64 %127, %94
br i1 %122, label %141, label %123
123: ; preds = %117, %119
%124 = phi i64 [ %127, %119 ], [ 0, %117 ]
%125 = phi i64 [ %121, %119 ], [ 1, %117 ]
%126 = phi double [ %120, %119 ], [ 0.000000e+00, %117 ]
%127 = add nuw nsw i64 %124, 1
%128 = icmp slt i64 %127, %37
br i1 %128, label %129, label %119
129: ; preds = %123
%130 = mul nsw i64 %124, %37
br label %131
131: ; preds = %129, %131
%132 = phi i64 [ %125, %129 ], [ %139, %131 ]
%133 = phi double [ %126, %129 ], [ %138, %131 ]
%134 = add nsw i64 %132, %130
%135 = getelementptr inbounds double, double* %33, i64 %134
%136 = load double, double* %135
%137 = tail call double @llvm.fabs.f64(double %136)
%138 = fadd double %133, %137
%139 = add nuw nsw i64 %132, 1
%140 = icmp eq i64 %139, %95
br i1 %140, label %119, label %131
141: ; preds = %119
%142 = fcmp oeq double %120, 0.000000e+00
br i1 %142, label %469, label %143
143: ; preds = %141
%144 = icmp ult i32 %118, 3
br i1 %144, label %145, label %148
145: ; preds = %143
%146 = fmul double %120, 2.000000e-01
%147 = fdiv double %146, %93
br label %148
148: ; preds = %145, %143
%149 = phi double [ %147, %145 ], [ 0.000000e+00, %143 ]
br i1 %91, label %150, label %156
150: ; preds = %148
%151 = icmp ugt i32 %118, 3
br label %238
152: ; preds = %451, %238
%153 = add nuw nsw i64 %241, 1
%154 = add nuw i32 %240, 1
%155 = icmp eq i64 %248, %96
br i1 %155, label %156, label %238
156: ; preds = %152, %148
br i1 %42, label %157, label %466
157: ; preds = %156
br i1 %110, label %236, label %158
158: ; preds = %157
br i1 %113, label %210, label %159
159: ; preds = %158, %159
%160 = phi i64 [ %207, %159 ], [ 0, %158 ]
%161 = phi i64 [ %208, %159 ], [ 0, %158 ]
%162 = getelementptr inbounds double, double* %35, i64 %160
%163 = bitcast double* %162 to <2 x double>*
%164 = load <2 x double>, <2 x double>* %163
%165 = getelementptr inbounds double, double* %162, i64 2
%166 = bitcast double* %165 to <2 x double>*
%167 = load <2 x double>, <2 x double>* %166
%168 = getelementptr inbounds double, double* %34, i64 %160
%169 = bitcast double* %168 to <2 x double>*
%170 = load <2 x double>, <2 x double>* %169
%171 = getelementptr inbounds double, double* %168, i64 2
%172 = bitcast double* %171 to <2 x double>*
%173 = load <2 x double>, <2 x double>* %172
%174 = fadd <2 x double> %164, %170
%175 = fadd <2 x double> %167, %173
%176 = bitcast double* %168 to <2 x double>*
store <2 x double> %174, <2 x double>* %176
%177 = bitcast double* %171 to <2 x double>*
store <2 x double> %175, <2 x double>* %177
%178 = getelementptr inbounds double, double* %1, i64 %160
%179 = bitcast double* %178 to <2 x double>*
store <2 x double> %174, <2 x double>* %179
%180 = getelementptr inbounds double, double* %178, i64 2
%181 = bitcast double* %180 to <2 x double>*
store <2 x double> %175, <2 x double>* %181
%182 = bitcast double* %162 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %182
%183 = bitcast double* %165 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %183
%184 = or i64 %160, 4
%185 = getelementptr inbounds double, double* %35, i64 %184
%186 = bitcast double* %185 to <2 x double>*
%187 = load <2 x double>, <2 x double>* %186
%188 = getelementptr inbounds double, double* %185, i64 2
%189 = bitcast double* %188 to <2 x double>*
%190 = load <2 x double>, <2 x double>* %189
%191 = getelementptr inbounds double, double* %34, i64 %184
%192 = bitcast double* %191 to <2 x double>*
%193 = load <2 x double>, <2 x double>* %192
%194 = getelementptr inbounds double, double* %191, i64 2
%195 = bitcast double* %194 to <2 x double>*
%196 = load <2 x double>, <2 x double>* %195
%197 = fadd <2 x double> %187, %193
%198 = fadd <2 x double> %190, %196
%199 = bitcast double* %191 to <2 x double>*
store <2 x double> %197, <2 x double>* %199
%200 = bitcast double* %194 to <2 x double>*
store <2 x double> %198, <2 x double>* %200
%201 = getelementptr inbounds double, double* %1, i64 %184
%202 = bitcast double* %201 to <2 x double>*
store <2 x double> %197, <2 x double>* %202
%203 = getelementptr inbounds double, double* %201, i64 2
%204 = bitcast double* %203 to <2 x double>*
store <2 x double> %198, <2 x double>* %204
%205 = bitcast double* %185 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %205
%206 = bitcast double* %188 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %206
%207 = add nuw i64 %160, 8
%208 = add i64 %161, 2
%209 = icmp eq i64 %208, %114
br i1 %209, label %210, label %159
210: ; preds = %159, %158
%211 = phi i64 [ 0, %158 ], [ %207, %159 ]
br i1 %115, label %235, label %212
212: ; preds = %210
%213 = getelementptr inbounds double, double* %35, i64 %211
%214 = bitcast double* %213 to <2 x double>*
%215 = load <2 x double>, <2 x double>* %214
%216 = getelementptr inbounds double, double* %213, i64 2
%217 = bitcast double* %216 to <2 x double>*
%218 = load <2 x double>, <2 x double>* %217
%219 = getelementptr inbounds double, double* %34, i64 %211
%220 = bitcast double* %219 to <2 x double>*
%221 = load <2 x double>, <2 x double>* %220
%222 = getelementptr inbounds double, double* %219, i64 2
%223 = bitcast double* %222 to <2 x double>*
%224 = load <2 x double>, <2 x double>* %223
%225 = fadd <2 x double> %215, %221
%226 = fadd <2 x double> %218, %224
%227 = bitcast double* %219 to <2 x double>*
store <2 x double> %225, <2 x double>* %227
%228 = bitcast double* %222 to <2 x double>*
store <2 x double> %226, <2 x double>* %228
%229 = getelementptr inbounds double, double* %1, i64 %211
%230 = bitcast double* %229 to <2 x double>*
store <2 x double> %225, <2 x double>* %230
%231 = getelementptr inbounds double, double* %229, i64 2
%232 = bitcast double* %231 to <2 x double>*
store <2 x double> %226, <2 x double>* %232
%233 = bitcast double* %213 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %233
%234 = bitcast double* %216 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %234
br label %235
235: ; preds = %210, %212
br i1 %116, label %466, label %236
236: ; preds = %157, %235
%237 = phi i64 [ 0, %157 ], [ %111, %235 ]
br label %456
238: ; preds = %150, %152
%239 = phi i64 [ 0, %150 ], [ %248, %152 ]
%240 = phi i32 [ 2, %150 ], [ %154, %152 ]
%241 = phi i64 [ 1, %150 ], [ %153, %152 ]
%242 = mul i64 %100, %239
%243 = mul i64 %239, %37
%244 = add i64 %243, %37
%245 = getelementptr double, double* %33, i64 %244
%246 = bitcast double* %245 to i8*
%247 = add i64 %104, %243
%248 = add nuw nsw i64 %239, 1
%249 = icmp slt i64 %248, %37
br i1 %249, label %250, label %152
250: ; preds = %238
%251 = sext i32 %240 to i64
%252 = mul nsw i64 %239, %37
%253 = getelementptr inbounds double, double* %1, i64 %239
%254 = getelementptr inbounds double, double* %35, i64 %239
%255 = icmp eq i64 %239, 0
br label %256
256: ; preds = %250, %451
%257 = phi i64 [ 0, %250 ], [ %455, %451 ]
%258 = phi i64 [ %241, %250 ], [ %452, %451 ]
%259 = phi i64 [ %251, %250 ], [ %453, %451 ]
%260 = add i64 %239, %257
%261 = sub i64 %105, %260
%262 = add i64 %257, 2
%263 = getelementptr double, double* %33, i64 %262
%264 = bitcast double* %263 to i8*
%265 = getelementptr i8, i8* %264, i64 %242
%266 = mul i64 %100, %257
%267 = add i64 %242, %266
%268 = getelementptr i8, i8* %103, i64 %267
%269 = mul i64 %257, %37
%270 = add i64 %247, %269
%271 = getelementptr double, double* %33, i64 %270
%272 = bitcast double* %271 to i8*
%273 = add nsw i64 %258, %252
%274 = getelementptr inbounds double, double* %33, i64 %273
%275 = load double, double* %274
%276 = tail call double @llvm.fabs.f64(double %275)
%277 = fmul double %276, 1.000000e+02
br i1 %151, label %278, label %290
278: ; preds = %256
%279 = load double, double* %253
%280 = tail call double @llvm.fabs.f64(double %279)
%281 = fadd double %277, %280
%282 = fcmp oeq double %281, %280
br i1 %282, label %283, label %290
283: ; preds = %278
%284 = getelementptr inbounds double, double* %1, i64 %258
%285 = load double, double* %284
%286 = tail call double @llvm.fabs.f64(double %285)
%287 = fadd double %277, %286
%288 = fcmp oeq double %287, %286
br i1 %288, label %289, label %290
289: ; preds = %283
store double 0.000000e+00, double* %274
br label %451
290: ; preds = %283, %278, %256
%291 = fcmp ogt double %276, %149
br i1 %291, label %292, label %451
292: ; preds = %290
%293 = getelementptr inbounds double, double* %1, i64 %258
%294 = load double, double* %293
%295 = load double, double* %253
%296 = fsub double %294, %295
%297 = tail call double @llvm.fabs.f64(double %296)
%298 = fadd double %277, %297
%299 = fcmp oeq double %298, %297
br i1 %299, label %300, label %302
300: ; preds = %292
%301 = fdiv double %275, %296
br label %313
302: ; preds = %292
%303 = fmul double %296, 5.000000e-01
%304 = fdiv double %303, %275
%305 = tail call double @llvm.fabs.f64(double %304)
%306 = tail call double @llvm.fmuladd.f64(double %304, double %304, double 1.000000e+00)
%307 = tail call double @sqrt(double %306)
%308 = fadd double %305, %307
%309 = fdiv double 1.000000e+00, %308
%310 = fcmp olt double %304, 0.000000e+00
%311 = fneg double %309
%312 = select i1 %310, double %311, double %309
br label %313
313: ; preds = %302, %300
%314 = phi double [ %301, %300 ], [ %312, %302 ]
%315 = tail call double @llvm.fmuladd.f64(double %314, double %314, double 1.000000e+00)
%316 = tail call double @sqrt(double %315)
%317 = fdiv double 1.000000e+00, %316
%318 = fmul double %314, %317
%319 = fadd double %317, 1.000000e+00
%320 = fdiv double %318, %319
%321 = load double, double* %274
%322 = fmul double %314, %321
%323 = load double, double* %254
%324 = fsub double %323, %322
store double %324, double* %254
%325 = getelementptr inbounds double, double* %35, i64 %258
%326 = load double, double* %325
%327 = fadd double %322, %326
store double %327, double* %325
%328 = load double, double* %253
%329 = fsub double %328, %322
store double %329, double* %253
%330 = load double, double* %293
%331 = fadd double %322, %330
store double %331, double* %293
store double 0.000000e+00, double* %274
br i1 %255, label %334, label %332
332: ; preds = %313
%333 = fneg double %318
br label %338
334: ; preds = %338, %313
%335 = icmp ult i64 %248, %258
br i1 %335, label %336, label %354
336: ; preds = %334
%337 = fneg double %318
br label %398
338: ; preds = %332, %338
%339 = phi i64 [ 0, %332 ], [ %352, %338 ]
%340 = mul nsw i64 %339, %37
%341 = add nsw i64 %340, %239
%342 = getelementptr inbounds double, double* %33, i64 %341
%343 = load double, double* %342
%344 = add nsw i64 %340, %258
%345 = getelementptr inbounds double, double* %33, i64 %344
%346 = load double, double* %345
%347 = tail call double @llvm.fmuladd.f64(double %343, double %320, double %346)
%348 = tail call double @llvm.fmuladd.f64(double %333, double %347, double %343)
store double %348, double* %342
%349 = fneg double %346
%350 = tail call double @llvm.fmuladd.f64(double %349, double %320, double %343)
%351 = tail call double @llvm.fmuladd.f64(double %318, double %350, double %346)
store double %351, double* %345
%352 = add nuw nsw i64 %339, 1
%353 = icmp eq i64 %352, %239
br i1 %353, label %334, label %338
354: ; preds = %398, %334
%355 = add nuw nsw i64 %258, 1
%356 = icmp slt i64 %355, %37
br i1 %356, label %357, label %414
357: ; preds = %354
%358 = mul nsw i64 %258, %37
%359 = fneg double %318
%360 = icmp ult i64 %261, 2
br i1 %360, label %396, label %361
361: ; preds = %357
%362 = icmp ult i8* %265, %272
%363 = icmp ult i8* %268, %246
%364 = and i1 %362, %363
br i1 %364, label %396, label %365
365: ; preds = %361
%366 = and i64 %261, -2
%367 = add i64 %259, %366
%368 = insertelement <2 x double> poison, double %320, i64 0
%369 = shufflevector <2 x double> %368, <2 x double> poison, <2 x i32> zeroinitializer
%370 = insertelement <2 x double> poison, double %359, i64 0
%371 = shufflevector <2 x double> %370, <2 x double> poison, <2 x i32> zeroinitializer
%372 = insertelement <2 x double> poison, double %318, i64 0
%373 = shufflevector <2 x double> %372, <2 x double> poison, <2 x i32> zeroinitializer
br label %374
374: ; preds = %374, %365
%375 = phi i64 [ 0, %365 ], [ %392, %374 ]
%376 = add i64 %259, %375
%377 = add nsw i64 %376, %252
%378 = getelementptr inbounds double, double* %33, i64 %377
%379 = bitcast double* %378 to <2 x double>*
%380 = load <2 x double>, <2 x double>* %379
%381 = add nsw i64 %376, %358
%382 = getelementptr inbounds double, double* %33, i64 %381
%383 = bitcast double* %382 to <2 x double>*
%384 = load <2 x double>, <2 x double>* %383
%385 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %380, <2 x double> %369, <2 x double> %384)
%386 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %371, <2 x double> %385, <2 x double> %380)
%387 = bitcast double* %378 to <2 x double>*
store <2 x double> %386, <2 x double>* %387
%388 = fneg <2 x double> %384
%389 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %388, <2 x double> %369, <2 x double> %380)
%390 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %373, <2 x double> %389, <2 x double> %384)
%391 = bitcast double* %382 to <2 x double>*
store <2 x double> %390, <2 x double>* %391
%392 = add nuw i64 %375, 2
%393 = icmp eq i64 %392, %366
br i1 %393, label %394, label %374
394: ; preds = %374
%395 = icmp eq i64 %261, %366
br i1 %395, label %414, label %396
396: ; preds = %361, %357, %394
%397 = phi i64 [ %259, %361 ], [ %259, %357 ], [ %367, %394 ]
br label %417
398: ; preds = %336, %398
%399 = phi i64 [ %241, %336 ], [ %412, %398 ]
%400 = add nsw i64 %399, %252
%401 = getelementptr inbounds double, double* %33, i64 %400
%402 = load double, double* %401
%403 = mul nsw i64 %399, %37
%404 = add nsw i64 %403, %258
%405 = getelementptr inbounds double, double* %33, i64 %404
%406 = load double, double* %405
%407 = tail call double @llvm.fmuladd.f64(double %402, double %320, double %406)
%408 = tail call double @llvm.fmuladd.f64(double %337, double %407, double %402)
store double %408, double* %401
%409 = fneg double %406
%410 = tail call double @llvm.fmuladd.f64(double %409, double %320, double %402)
%411 = tail call double @llvm.fmuladd.f64(double %318, double %410, double %406)
store double %411, double* %405
%412 = add nuw nsw i64 %399, 1
%413 = icmp eq i64 %412, %258
br i1 %413, label %354, label %398
414: ; preds = %417, %394, %354
br i1 %42, label %415, label %448
415: ; preds = %414
%416 = fneg double %318
br label %432
417: ; preds = %396, %417
%418 = phi i64 [ %430, %417 ], [ %397, %396 ]
%419 = add nsw i64 %418, %252
%420 = getelementptr inbounds double, double* %33, i64 %419
%421 = load double, double* %420
%422 = add nsw i64 %418, %358
%423 = getelementptr inbounds double, double* %33, i64 %422
%424 = load double, double* %423
%425 = tail call double @llvm.fmuladd.f64(double %421, double %320, double %424)
%426 = tail call double @llvm.fmuladd.f64(double %359, double %425, double %421)
store double %426, double* %420
%427 = fneg double %424
%428 = tail call double @llvm.fmuladd.f64(double %427, double %320, double %421)
%429 = tail call double @llvm.fmuladd.f64(double %318, double %428, double %424)
store double %429, double* %423
%430 = add nsw i64 %418, 1
%431 = icmp slt i64 %430, %37
br i1 %431, label %417, label %414
432: ; preds = %415, %432
%433 = phi i64 [ 0, %415 ], [ %446, %432 ]
%434 = mul nsw i64 %433, %37
%435 = add nsw i64 %434, %239
%436 = getelementptr inbounds double, double* %0, i64 %435
%437 = load double, double* %436
%438 = add nsw i64 %434, %258
%439 = getelementptr inbounds double, double* %0, i64 %438
%440 = load double, double* %439
%441 = tail call double @llvm.fmuladd.f64(double %437, double %320, double %440)
%442 = tail call double @llvm.fmuladd.f64(double %416, double %441, double %437)
store double %442, double* %436
%443 = fneg double %440
%444 = tail call double @llvm.fmuladd.f64(double %443, double %320, double %437)
%445 = tail call double @llvm.fmuladd.f64(double %318, double %444, double %440)
store double %445, double* %439
%446 = add nuw nsw i64 %433, 1
%447 = icmp eq i64 %446, %97
br i1 %447, label %448, label %432
448: ; preds = %432, %414
%449 = load i32, i32* %2
%450 = add nsw i32 %449, 1
store i32 %450, i32* %2
br label %451
451: ; preds = %289, %448, %290
%452 = add nuw nsw i64 %258, 1
%453 = add nsw i64 %259, 1
%454 = icmp eq i64 %452, %97
%455 = add i64 %257, 1
br i1 %454, label %152, label %256
456: ; preds = %236, %456
%457 = phi i64 [ %464, %456 ], [ %237, %236 ]
%458 = getelementptr inbounds double, double* %35, i64 %457
%459 = load double, double* %458
%460 = getelementptr inbounds double, double* %34, i64 %457
%461 = load double, double* %460
%462 = fadd double %459, %461
store double %462, double* %460
%463 = getelementptr inbounds double, double* %1, i64 %457
store double %462, double* %463
store double 0.000000e+00, double* %458
%464 = add nuw nsw i64 %457, 1
%465 = icmp eq i64 %464, %98
br i1 %465, label %466, label %456
466: ; preds = %456, %235, %156
%467 = add nuw nsw i32 %118, 1
%468 = icmp eq i32 %467, 50
br i1 %468, label %469, label %117
469: ; preds = %117, %141, %466, %17
%470 = phi double* [ %22, %17 ], [ %33, %466 ], [ %33, %141 ], [ %33, %117 ]
%471 = phi double* [ %24, %17 ], [ %34, %466 ], [ %34, %141 ], [ %34, %117 ]
%472 = phi double* [ %26, %17 ], [ %35, %466 ], [ %35, %141 ], [ %35, %117 ]
%473 = phi i32 [ 0, %17 ], [ 1, %466 ], [ 1, %141 ], [ 1, %117 ]
%474 = icmp ne double* %470, null
%475 = getelementptr inbounds [25 x double], [25 x double]* %6, i64 0, i64 0
%476 = icmp ne double* %470, %475
%477 = and i1 %474, %476
br i1 %477, label %478, label %480
478: ; preds = %469
%479 = bitcast double* %470 to i8*
br label %480
480: ; preds = %478, %469
%481 = icmp ne double* %471, null
%482 = getelementptr inbounds [5 x double], [5 x double]* %7, i64 0, i64 0
%483 = icmp ne double* %471, %482
%484 = and i1 %481, %483
br i1 %484, label %485, label %487
485: ; preds = %480
%486 = bitcast double* %471 to i8*
br label %487
487: ; preds = %485, %480
%488 = icmp ne double* %472, null
%489 = getelementptr inbounds [5 x double], [5 x double]* %8, i64 0, i64 0
%490 = icmp ne double* %472, %489
%491 = and i1 %488, %490
br i1 %491, label %492, label %494
492: ; preds = %487
%493 = bitcast double* %472 to i8*
br label %494
494: ; preds = %492, %487
ret i32 %473
}