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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ eigen_symm_2d(double *, double **, double **);
int fabs(double);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, double, double);
int /*<<< orphan*/ free_matrix2(double **);
double **matrix_clone(double **, int, int);
int /*<<< orphan*/ matrix_copy(double **, double **, int, int);
int /*<<< orphan*/ matrix_mult(double **, double **, double **, int, int, int);
double **new_matrix2(int, int);
int /*<<< orphan*/ reversei(int *, int *, int);
int /*<<< orphan*/ sort_indices(double *, int *, int);
int sqrt(int);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ transpose(double **, double **, int, int);
void eigen_symm(double z[], double **V, double **X, int n) {
  if (n == 2) {
    eigen_symm_2d(z, V, X);
    return;
  }
  int i, j;
  double tolerance = 1e-10;
  double **A = matrix_clone(X, n, n);
  double **B = new_matrix2(n, n);
  double **G = new_matrix2(n, n);
  double **Gt = new_matrix2(n, n);
  int cnt = 1;
  for (i = 0; i < n; i++) {
    V[i][i] = 1;
    for (j = i + 1; j < n; j++)
      V[i][j] = V[j][i] = 0;
  }
  while (1) {
    double d_off = 0, d_diag = 0;
    for (i = 0; i < n; i++) {
      d_diag += A[i][i] * A[i][i];
      for (j = i + 1; j < n; j++)
        d_off = ((d_off) > (fabs(A[i][j])) ? (d_off) : (fabs(A[i][j])));
    }
    d_diag = sqrt(d_diag / (double)n);
    if (d_off < ((tolerance * d_diag) > (tolerance) ? (tolerance * d_diag)
                                                    : (tolerance)))
      break;
    if (cnt++ % 1000 == 0)
      fprintf(stderr, "d_off = %e, d_diag = %e\n", d_off, d_diag);
    double pivot = 0;
    int ip = 0, jp = 0;
    for (i = 0; i < n; i++) {
      for (j = i + 1; j < n; j++) {
        double p = fabs(A[i][j]);
        if (p > pivot) {
          pivot = p;
          ip = i;
          jp = j;
        }
      }
    }
    double a = (A[jp][jp] - A[ip][ip]) / (2 * A[ip][jp]);
    double t = 1 / (fabs(a) + sqrt(1 + a * a));
    if (a < 0)
      t = -t;
    double c = 1 / sqrt(1 + t * t);
    double s = t * c;
    for (i = 0; i < n; i++) {
      G[i][i] = 1;
      for (j = i + 1; j < n; j++)
        G[i][j] = G[j][i] = 0;
    }
    G[ip][ip] = G[jp][jp] = c;
    G[ip][jp] = s;
    G[jp][ip] = -s;
    transpose(Gt, G, n, n);
    matrix_mult(B, A, G, n, n, n);
    matrix_mult(A, Gt, B, n, n, n);
    matrix_mult(B, Gt, V, n, n, n);
    matrix_copy(V, B, n, n);
  }
  int idx[n];
  double z2[n];
  for (i = 0; i < n; i++)
    z[i] = A[i][i];
  sort_indices(z, idx, n);
  if (z[idx[0]] < -tolerance) {
    reversei(idx, idx, n);
  }
  for (i = 0; i < n; i++)
    z2[i] = z[idx[i]];
  for (i = 0; i < n; i++)
    z[i] = z2[i];
  for (i = 0; i < n; i++)
    for (j = 0; j < n; j++)
      B[i][j] = V[idx[i]][j];
  matrix_copy(V, B, n, n);
  free_matrix2(A);
  free_matrix2(B);
  free_matrix2(G);
  free_matrix2(Gt);
}


x86 assembly (clang, -O0):
<eigen_symm>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
cmpl   $0x2,-0x1c(%rbp)
jne    11fa <eigen_symm+0x3a>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
call   10e0 <eigen_symm_2d@plt>
jmp    1a7a <eigen_symm+0x8ba>
movsd  0xdfe(%rip),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x1c(%rbp),%edx
call   1030 <matrix_clone@plt>
mov    %rax,-0x38(%rbp)
mov    -0x1c(%rbp),%edi
mov    -0x1c(%rbp),%esi
call   10b0 <new_matrix2@plt>
mov    %rax,-0x40(%rbp)
mov    -0x1c(%rbp),%edi
mov    -0x1c(%rbp),%esi
call   10b0 <new_matrix2@plt>
mov    %rax,-0x48(%rbp)
mov    -0x1c(%rbp),%edi
mov    -0x1c(%rbp),%esi
call   10b0 <new_matrix2@plt>
mov    %rax,-0x50(%rbp)
movl   $0x1,-0x54(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12e4 <eigen_symm+0x124>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  0xd8f(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12d1 <eigen_symm+0x111>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1287 <eigen_symm+0xc7>
jmp    12d6 <eigen_symm+0x116>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1255 <eigen_symm+0x95>
jmp    12e9 <eigen_symm+0x129>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1400 <eigen_symm+0x240>
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13ed <eigen_symm+0x22d>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1050 <fabs@plt>
movsd  -0xc0(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jbe    13ac <eigen_symm+0x1ec>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    13d2 <eigen_symm+0x212>
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1050 <fabs@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1351 <eigen_symm+0x191>
jmp    13f2 <eigen_symm+0x232>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1300 <eigen_symm+0x140>
movsd  -0x68(%rbp),%xmm0
cvtsi2sdl -0x1c(%rbp),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   10d0 <sqrt@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
ucomisd -0x30(%rbp),%xmm0
jbe    1459 <eigen_symm+0x299>
movsd  -0x30(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    1466 <eigen_symm+0x2a6>
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm1
ff
movsd  -0xd8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1485 <eigen_symm+0x2c5>
jmp    183f <eigen_symm+0x67f>
mov    -0x54(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x54(%rbp)
mov    $0x3e8,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    14c0 <eigen_symm+0x300>
mov    0x2b38(%rip),%rax
mov    (%rax),%edi
movsd  -0x60(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
lea    0xb5d(%rip),%rsi
call   1060 <fprintf@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x74(%rbp)
movl   $0x0,-0x78(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    156d <eigen_symm+0x3ad>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    155a <eigen_symm+0x39a>
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1050 <fabs@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    1547 <eigen_symm+0x387>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x78(%rbp)
jmp    154c <eigen_symm+0x38c>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    14f2 <eigen_symm+0x332>
jmp    155f <eigen_symm+0x39f>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    14dd <eigen_symm+0x31d>
mov    -0x38(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x78(%rbp),%rcx
movsd  0xa61(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
call   1050 <fabs@plt>
mov    %eax,-0xdc(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0xa19(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   10d0 <sqrt@plt>
mov    -0xdc(%rbp),%ecx
add    %eax,%ecx
mov    $0x1,%eax
cltd
idiv   %ecx
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jbe    1650 <eigen_symm+0x490>
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0x99c(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   10d0 <sqrt@plt>
mov    %eax,%ecx
mov    $0x1,%eax
cltd
idiv   %ecx
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    173d <eigen_symm+0x57d>
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  0x936(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    172a <eigen_symm+0x56a>
mov    -0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    16e0 <eigen_symm+0x520>
jmp    172f <eigen_symm+0x56f>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    16ae <eigen_symm+0x4ee>
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    -0x1c(%rbp),%ecx
call   1070 <transpose@plt>
mov    -0x40(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x48(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x1c(%rbp),%r8d
mov    -0x1c(%rbp),%r9d
call   1080 <matrix_mult@plt>
mov    -0x38(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x40(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x1c(%rbp),%r8d
mov    -0x1c(%rbp),%r9d
call   1080 <matrix_mult@plt>
mov    -0x40(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x10(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x1c(%rbp),%r8d
mov    -0x1c(%rbp),%r9d
call   1080 <matrix_mult@plt>
mov    -0x10(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    -0x1c(%rbp),%ecx
call   1040 <matrix_copy@plt>
jmp    12e9 <eigen_symm+0x129>
mov    -0x1c(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0xa8(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xf0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xb0(%rbp)
mov    -0x1c(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xe8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xb8(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    18d8 <eigen_symm+0x718>
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    189c <eigen_symm+0x6dc>
mov    -0xf0(%rbp),%rsi
mov    -0x8(%rbp),%rdi
mov    -0x1c(%rbp),%edx
call   10a0 <sort_indices@plt>
mov    -0xf0(%rbp),%rcx
mov    -0x8(%rbp),%rax
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x30(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    1936 <eigen_symm+0x776>
mov    -0xf0(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    %rsi,%rdi
call   10c0 <reversei@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    197f <eigen_symm+0x7bf>
mov    -0xe8(%rbp),%rax
mov    -0xf0(%rbp),%rdx
mov    -0x8(%rbp),%rcx
movslq -0x20(%rbp),%rsi
movslq (%rdx,%rsi,4),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    193d <eigen_symm+0x77d>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    19bd <eigen_symm+0x7fd>
mov    -0xe8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1986 <eigen_symm+0x7c6>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1a39 <eigen_symm+0x879>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1a26 <eigen_symm+0x866>
mov    -0xf0(%rbp),%rcx
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    19d7 <eigen_symm+0x817>
jmp    1a2b <eigen_symm+0x86b>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    19c4 <eigen_symm+0x804>
mov    -0x10(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    -0x1c(%rbp),%ecx
call   1040 <matrix_copy@plt>
mov    -0x38(%rbp),%rdi
call   1090 <free_matrix2@plt>
mov    -0x40(%rbp),%rdi
call   1090 <free_matrix2@plt>
mov    -0x48(%rbp),%rdi
call   1090 <free_matrix2@plt>
mov    -0x50(%rbp),%rdi
call   1090 <free_matrix2@plt>
mov    -0xa8(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<eigen_symm>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %rsi,%r14
cmp    $0x2,%ecx
jne    1202 <eigen_symm+0x32>
mov    %r14,%rsi
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    10f0 <eigen_symm_2d@plt>
mov    %ecx,%r13d
mov    %rdi,-0x60(%rbp)
mov    %rdx,%rdi
mov    %ecx,%esi
mov    %ecx,%edx
call   1030 <matrix_clone@plt>
mov    %rax,-0x48(%rbp)
mov    %r13d,%edi
mov    %r13d,%esi
call   10c0 <new_matrix2@plt>
mov    %rax,-0x68(%rbp)
mov    %r13d,%edi
mov    %r13d,%esi
call   10c0 <new_matrix2@plt>
mov    %rax,-0xa0(%rbp)
mov    %r13d,%edi
mov    %r13d,%esi
call   10c0 <new_matrix2@plt>
mov    %rax,-0x98(%rbp)
mov    %r13d,%ecx
movabs $0x3ff0000000000000,%r10
test   %r13d,%r13d
jle    12c5 <eigen_symm+0xf5>
xor    %r8d,%r8d
mov    %rcx,%r9
mov    %r14,%rax
jmp    127d <eigen_symm+0xad>
nopl   0x0(%rax)
add    $0x8,%rax
add    $0xffffffffffffffff,%r9
cmp    %rcx,%r8
je     12bf <eigen_symm+0xef>
mov    %r8,%rsi
mov    (%r14,%r8,8),%rdi
mov    %r10,(%rdi,%r8,8)
add    $0x1,%r8
cmp    %rcx,%r8
jae    1270 <eigen_symm+0xa0>
lea    (%rdi,%rsi,8),%rdi
mov    $0x1,%ebx
nopw   0x0(%rax,%rax,1)
mov    (%rax,%rbx,8),%rdx
movq   $0x0,(%rdx,%rsi,8)
movq   $0x0,(%rdi,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r9
jne    12a0 <eigen_symm+0xd0>
jmp    1270 <eigen_symm+0xa0>
mov    %rcx,-0x58(%rbp)
jmp    12cc <eigen_symm+0xfc>
movslq %r13d,%rax
mov    %rax,-0x58(%rbp)
cvtsi2sd %r13d,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
lea    -0x2(%rcx),%rax
mov    %rax,-0x88(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    %r13d,-0x8c(%rbp)
mov    %r14,-0x70(%rbp)
mov    -0x48(%rbp),%r14
mov    %rcx,-0x30(%rbp)
jmp    13cd <eigen_symm+0x1fd>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addl   $0x1,-0x4c(%rbp)
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd -0x40(%rbp),%xmm1
mulsd  %xmm0,%xmm1
mov    (%rsi,%r15,8),%rax
movsd  %xmm0,(%rax,%r15,8)
mov    (%rsi,%r12,8),%rcx
movsd  %xmm0,(%rcx,%r12,8)
movsd  %xmm1,(%rcx,%r15,8)
xorpd  0xcda(%rip),%xmm1
movlpd %xmm1,(%rax,%r12,8)
mov    -0x98(%rbp),%r14
mov    %r14,%rdi
mov    %r13d,%edx
mov    %r13d,%ecx
mov    %rsi,%r12
call   1070 <transpose@plt>
mov    -0x68(%rbp),%rbx
mov    %rbx,%rdi
mov    -0x48(%rbp),%r15
mov    %r15,%rsi
mov    %r12,%rdx
mov    %r13d,%ecx
mov    %r13d,%r8d
mov    %r13d,%r9d
call   1080 <matrix_mult@plt>
mov    %r15,%rdi
mov    %r14,%rsi
mov    %rbx,%rdx
mov    %r13d,%ecx
mov    %r13d,%r8d
mov    %r13d,%r9d
call   1080 <matrix_mult@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
mov    -0x70(%rbp),%r14
mov    %r14,%rdx
mov    %r13d,%ecx
mov    %r13d,%r8d
mov    %r13d,%r9d
call   1080 <matrix_mult@plt>
mov    %r14,%rdi
mov    %r15,%r14
mov    %rbx,%rsi
mov    %r13d,%edx
mov    %r13d,%ecx
call   1040 <matrix_copy@plt>
mov    -0x30(%rbp),%rcx
xorpd  %xmm1,%xmm1
xorpd  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
test   %r13d,%r13d
jle    1490 <eigen_symm+0x2c0>
xorpd  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
xor    %r15d,%r15d
xorpd  %xmm1,%xmm1
jmp    141b <eigen_symm+0x24b>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x30(%rbp),%rcx
movsd  -0x80(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm1
cmp    %rcx,%r15
je     1490 <eigen_symm+0x2c0>
mov    %r15,%r12
mov    (%r14,%r15,8),%rax
movsd  (%rax,%r15,8),%xmm0
add    $0x1,%r15
cmp    -0x58(%rbp),%r15
jge    140e <eigen_symm+0x23e>
movsd  %xmm0,-0x78(%rbp)
movsd  %xmm1,-0x80(%rbp)
mov    %r12,%rbx
nop
movsd  0x8(%rax,%rbx,8),%xmm0
call   1050 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  -0x40(%rbp),%xmm1
ucomisd %xmm0,%xmm1
ja     1478 <eigen_symm+0x2a8>
mov    (%r14,%r12,8),%rax
movsd  0x8(%rax,%rbx,8),%xmm0
call   1050 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x40(%rbp)
cmp    %rbx,-0x88(%rbp)
je     1400 <eigen_symm+0x230>
mov    (%r14,%r12,8),%rax
add    $0x1,%rbx
jmp    1440 <eigen_symm+0x270>
nop
divsd  -0xa8(%rbp),%xmm1
ff
cvttsd2si %xmm1,%edi
call   10e0 <sqrt@plt>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movapd %xmm1,%xmm0
movsd  0xb4c(%rip),%xmm2
mulsd  %xmm2,%xmm0
maxsd  %xmm2,%xmm0
ucomisd -0x40(%rbp),%xmm0
ja     16ff <eigen_symm+0x52f>
imul   $0x26e978d5,-0x4c(%rbp),%eax
ror    $0x3,%eax
cmp    $0x418937,%eax
jbe    1590 <eigen_symm+0x3c0>
test   %r13d,%r13d
jle    15b3 <eigen_symm+0x3e3>
xor    %r13d,%r13d
xorpd  %xmm1,%xmm1
mov    $0x1,%r15d
xor    %r12d,%r12d
xor    %ebx,%ebx
mov    -0x30(%rbp),%rcx
jmp    151d <eigen_symm+0x34d>
nopl   (%rax)
movapd %xmm1,%xmm0
mov    -0x78(%rbp),%r15
add    $0x1,%r15
movapd %xmm0,%xmm1
mov    -0x80(%rbp),%r13
cmp    %rcx,%r13
je     15b8 <eigen_symm+0x3e8>
lea    0x1(%r13),%rax
cmp    -0x58(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    %r15,-0x78(%rbp)
jge    1500 <eigen_symm+0x330>
mov    -0x48(%rbp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  %xmm1,-0x40(%rbp)
mov    (%r14,%r13,8),%rax
movsd  (%rax,%r15,8),%xmm0
call   1050 <fabs@plt>
mov    -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  -0x40(%rbp),%xmm1
ucomisd %xmm1,%xmm0
cmova  %r13d,%ebx
cmova  %r15d,%r12d
maxsd  %xmm1,%xmm0
add    $0x1,%r15
movapd %xmm0,%xmm1
cmp    %r15,%rcx
jne    1540 <eigen_symm+0x370>
jmp    1504 <eigen_symm+0x334>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x2a49(%rip),%rax
mov    (%rax),%edi
lea    0xa90(%rip),%rsi
movsd  -0x40(%rbp),%xmm0
call   1060 <fprintf@plt>
test   %r13d,%r13d
jg     14e5 <eigen_symm+0x315>
xor    %ebx,%ebx
xor    %r12d,%r12d
movslq %r12d,%r15
mov    -0x48(%rbp),%rcx
mov    (%rcx,%r15,8),%rax
movsd  (%rax,%r15,8),%xmm0
movslq %ebx,%r12
mov    (%rcx,%r12,8),%rax
subsd  (%rax,%r12,8),%xmm0
movsd  (%rax,%r15,8),%xmm1
addsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
movapd %xmm0,-0x40(%rbp)
call   1050 <fabs@plt>
mov    %eax,%ebx
movapd -0x40(%rbp),%xmm0
mulsd  %xmm0,%xmm0
movsd  0xa07(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   10e0 <sqrt@plt>
lea    (%rax,%rbx,1),%ecx
add    %ebx,%eax
add    $0x1,%eax
cmp    $0x3,%eax
mov    $0x0,%ebx
cmovae %ebx,%ecx
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
movapd -0x40(%rbp),%xmm2
cmpltsd 0x9e2(%rip),%xmm2
movapd %xmm2,%xmm0
andnpd %xmm1,%xmm0
xorpd  0x9da(%rip),%xmm1
andpd  %xmm2,%xmm1
orpd   %xmm0,%xmm1
movapd %xmm1,-0x40(%rbp)
movapd %xmm1,%xmm0
mulsd  %xmm1,%xmm0
addsd  0x9a5(%rip),%xmm0
cvttsd2si %xmm0,%edi
call   10e0 <sqrt@plt>
mov    -0x30(%rbp),%r11
lea    0x1(%rax),%ecx
cmp    $0x3,%ecx
cmovae %ebx,%eax
mov    -0x8c(%rbp),%ecx
mov    %ecx,%r13d
test   %ecx,%ecx
mov    -0xa0(%rbp),%rsi
movabs $0x3ff0000000000000,%r14
jle    1310 <eigen_symm+0x140>
mov    %r11,%r9
mov    %rsi,%r10
xor    %r8d,%r8d
jmp    16c1 <eigen_symm+0x4f1>
cs nopw 0x0(%rax,%rax,1)
add    $0x8,%r10
add    $0xffffffffffffffff,%r9
cmp    %r11,%r8
je     1310 <eigen_symm+0x140>
mov    %r8,%rdi
mov    (%rsi,%r8,8),%rcx
mov    %r14,(%rcx,%r8,8)
add    $0x1,%r8
cmp    -0x58(%rbp),%r8
jge    16b0 <eigen_symm+0x4e0>
lea    (%rcx,%rdi,8),%rbx
mov    $0x1,%edx
nop
mov    (%r10,%rdx,8),%rcx
movq   $0x0,(%rcx,%rdi,8)
movq   $0x0,(%rbx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r9
jne    16e0 <eigen_symm+0x510>
jmp    16b0 <eigen_symm+0x4e0>
mov    %rsp,-0x88(%rbp)
mov    %rsp,%r15
mov    -0x30(%rbp),%rdx
lea    0xf(,%rdx,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r15
mov    %r15,%rsp
mov    %rsp,%rbx
lea    0xf(,%rdx,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rbx
mov    %rbx,%rsp
test   %r13d,%r13d
mov    -0x60(%rbp),%rdi
jle    17c8 <eigen_symm+0x5f8>
lea    -0x1(%rdx),%rcx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    1754 <eigen_symm+0x584>
xor    %ecx,%ecx
jmp    17aa <eigen_symm+0x5da>
and    $0xfffffffc,%edx
xor    %ecx,%ecx
nopl   0x0(%rax)
mov    (%r14,%rcx,8),%rsi
movsd  (%rsi,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rcx,8)
mov    0x8(%r14,%rcx,8),%rsi
movsd  0x8(%rsi,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rcx,8)
mov    0x10(%r14,%rcx,8),%rsi
movsd  0x10(%rsi,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rdi,%rcx,8)
mov    0x18(%r14,%rcx,8),%rsi
movsd  0x18(%rsi,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rdi,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1760 <eigen_symm+0x590>
test   %rax,%rax
je     17c8 <eigen_symm+0x5f8>
nop
mov    (%r14,%rcx,8),%rdx
movsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    17b0 <eigen_symm+0x5e0>
mov    %r15,%rsi
mov    %r13d,%edx
call   10b0 <sort_indices@plt>
mov    -0x60(%rbp),%rdi
movslq (%r15),%rax
movsd  0x82e(%rip),%xmm0
ucomisd (%rdi,%rax,8),%xmm0
jbe    17fb <eigen_symm+0x62b>
mov    %r15,%rdi
mov    %r15,%rsi
mov    %r13d,%edx
call   10d0 <reversei@plt>
mov    -0x60(%rbp),%rdi
mov    %r15,-0x40(%rbp)
mov    %r13d,%r15d
test   %r13d,%r13d
jle    1abc <eigen_symm+0x8ec>
mov    -0x30(%rbp),%rdx
lea    -0x1(%rdx),%rcx
mov    %edx,%r9d
and    $0x3,%r9d
cmp    $0x3,%rcx
jae    182b <eigen_symm+0x65b>
xor    %ecx,%ecx
mov    %r15d,%r8d
mov    -0x40(%rbp),%rax
jmp    1887 <eigen_symm+0x6b7>
and    $0xfffffffc,%edx
xor    %ecx,%ecx
mov    %r15d,%r8d
mov    -0x40(%rbp),%rax
nopw   0x0(%rax,%rax,1)
movslq (%rax,%rcx,4),%rsi
movsd  (%rdi,%rsi,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
movslq 0x4(%rax,%rcx,4),%rsi
movsd  (%rdi,%rsi,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rcx,8)
movslq 0x8(%rax,%rcx,4),%rsi
movsd  (%rdi,%rsi,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rcx,8)
movslq 0xc(%rax,%rcx,4),%rsi
movsd  (%rdi,%rsi,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1840 <eigen_symm+0x670>
test   %r9,%r9
je     18b7 <eigen_symm+0x6e7>
lea    (%rbx,%rcx,8),%rdx
lea    (%rax,%rcx,4),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movslq (%rcx,%rsi,4),%rax
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%r9
jne    18a0 <eigen_symm+0x6d0>
test   %r8d,%r8d
jle    1abc <eigen_symm+0x8ec>
mov    -0x30(%rbp),%r14
lea    0x0(,%r14,8),%rdx
mov    %rbx,%rsi
call   1090 <memcpy@plt>
mov    %r14d,%r10d
and    $0xfffffffc,%r10d
add    $0xfffffffffffffffc,%r10
mov    %r10,%r8
shr    $0x2,%r8
add    $0x1,%r8
mov    %r14d,%r11d
and    $0xfffffffc,%r11d
mov    %r8d,%r9d
and    $0x3,%r9d
and    $0xfffffffffffffffc,%r8
and    $0x3,%r14d
mov    %r9,%r12
shl    $0x5,%r12
xor    %r13d,%r13d
jmp    191d <eigen_symm+0x74d>
nopl   0x0(%rax)
add    $0x1,%r13
cmp    %rcx,%r13
je     1abc <eigen_symm+0x8ec>
mov    -0x40(%rbp),%rax
movslq (%rax,%r13,4),%rax
mov    -0x70(%rbp),%rdx
mov    (%rdx,%rax,8),%rax
mov    -0x68(%rbp),%rdx
mov    (%rdx,%r13,8),%rdx
cmp    $0x4,%r15d
jae    1950 <eigen_symm+0x780>
xor    %ebx,%ebx
mov    -0x30(%rbp),%rcx
jmp    1a30 <eigen_symm+0x860>
cs nopw 0x0(%rax,%rax,1)
mov    -0x30(%rbp),%rcx
lea    (%rax,%rcx,8),%rsi
cmp    %rsi,%rdx
jae    1970 <eigen_symm+0x7a0>
lea    (%rdx,%rcx,8),%rsi
cmp    %rsi,%rax
jae    1970 <eigen_symm+0x7a0>
xor    %ebx,%ebx
jmp    1a30 <eigen_symm+0x860>
nopl   (%rax)
cmp    $0xc,%r10
jae    197a <eigen_symm+0x7aa>
xor    %ebx,%ebx
jmp    19dc <eigen_symm+0x80c>
mov    %r8,%rdi
xor    %ebx,%ebx
nop
movups (%rax,%rbx,8),%xmm0
movups 0x10(%rax,%rbx,8),%xmm1
movups %xmm0,(%rdx,%rbx,8)
movups %xmm1,0x10(%rdx,%rbx,8)
movups 0x20(%rax,%rbx,8),%xmm0
movups 0x30(%rax,%rbx,8),%xmm1
movups %xmm0,0x20(%rdx,%rbx,8)
movups %xmm1,0x30(%rdx,%rbx,8)
movups 0x40(%rax,%rbx,8),%xmm0
movups 0x50(%rax,%rbx,8),%xmm1
movups %xmm0,0x40(%rdx,%rbx,8)
movups %xmm1,0x50(%rdx,%rbx,8)
movupd 0x60(%rax,%rbx,8),%xmm0
movupd 0x70(%rax,%rbx,8),%xmm1
movupd %xmm0,0x60(%rdx,%rbx,8)
movupd %xmm1,0x70(%rdx,%rbx,8)
add    $0x10,%rbx
add    $0xfffffffffffffffc,%rdi
jne    1980 <eigen_symm+0x7b0>
test   %r9,%r9
je     1a1f <eigen_symm+0x84f>
lea    (%rdx,%rbx,8),%rdi
add    $0x10,%rdi
lea    (%rax,%rbx,8),%rsi
add    $0x10,%rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x10(%rsi,%rbx,1),%xmm0
movupd (%rsi,%rbx,1),%xmm1
movupd %xmm0,-0x10(%rdi,%rbx,1)
movupd %xmm1,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r12
jne    1a00 <eigen_symm+0x830>
mov    %r11,%rbx
mov    -0x30(%rbp),%rcx
cmp    %rcx,%r11
je     1910 <eigen_symm+0x740>
nop
mov    %rbx,%rdi
not    %rdi
add    %rcx,%rdi
test   %r14,%r14
je     1a64 <eigen_symm+0x894>
mov    %r14,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,(%rdx,%rbx,8)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rsi
jne    1a50 <eigen_symm+0x880>
cmp    $0x3,%rdi
mov    -0x30(%rbp),%rcx
jb     1910 <eigen_symm+0x740>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,(%rdx,%rbx,8)
movsd  0x8(%rax,%rbx,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rbx,8)
movsd  0x10(%rax,%rbx,8),%xmm0
movsd  %xmm0,0x10(%rdx,%rbx,8)
movsd  0x18(%rax,%rbx,8),%xmm0
movsd  %xmm0,0x18(%rdx,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%rcx
jne    1a80 <eigen_symm+0x8b0>
jmp    1910 <eigen_symm+0x740>
mov    -0x70(%rbp),%rdi
mov    -0x68(%rbp),%rbx
mov    %rbx,%rsi
mov    %r15d,%edx
mov    %r15d,%ecx
call   1040 <matrix_copy@plt>
mov    -0x48(%rbp),%rdi
call   10a0 <free_matrix2@plt>
mov    %rbx,%rdi
call   10a0 <free_matrix2@plt>
mov    -0xa0(%rbp),%rdi
call   10a0 <free_matrix2@plt>
mov    -0x98(%rbp),%rdi
call   10a0 <free_matrix2@plt>
mov    -0x88(%rbp),%rsp
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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