#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 */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fread(double *, int, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
int /*<<< orphan*/ matmat(double *, double *, double *, double, double, int);
int /*<<< orphan*/ matvec(double *, double *, double *, double, double, int);
double pow(double, double);
int /*<<< orphan*/ printf(char *, double, ...);
int /*<<< orphan*/ solve(double *, double *, int, int);
void test_2(void) {
  int m = 3;
  int size = 9;
  double *A = (double *)malloc(sizeof(double) * size);
  double *B = (double *)malloc(sizeof(double) * size);
  double *C = (double *)malloc(sizeof(double) * size);
  double *ansm = (double *)malloc(sizeof(double) * size);
  double *anssm = (double *)malloc(sizeof(double) * size);
  double *D = (double *)malloc(sizeof(double) * m);
  double *E = (double *)malloc(sizeof(double) * m);
  double *ansv = (double *)malloc(sizeof(double) * m);
  double *anss = (double *)malloc(sizeof(double) * m);
  double coeffs[2];
  FILE *f = fopen("input.dat", "r");
  fread(A, sizeof(double), size, f);
  fread(B, sizeof(double), size, f);
  fread(C, sizeof(double), size, f);
  fread(D, sizeof(double), m, f);
  fread(E, sizeof(double), m, f);
  fread(&coeffs[0], sizeof(double), 2, f);
  fread(ansm, sizeof(double), size, f);
  fread(ansv, sizeof(double), m, f);
  fread(anss, sizeof(double), m, f);
  fread(anssm, sizeof(double), size, f);
  int i;
  matmat(A, B, C, coeffs[0], coeffs[1], m);
  matvec(A, D, E, coeffs[0], coeffs[1], m);
  solve(A, D, m, 1);
  solve(A, B, m, m);
  double err_m = 0;
  double err_v = 0;
  double err_s = 0;
  double err_sm = 0;
  for (i = 0; i < size; i++) {
    err_m += (C[i] - ansm[i]) * (C[i] - ansm[i]);
  }
  for (i = 0; i < m; i++) {
    err_v += (E[i] - ansv[i]) * (E[i] - ansv[i]);
  }
  for (i = 0; i < m; i++) {
    err_s += (D[i] - anss[i]) * (D[i] - anss[i]);
  }
  for (i = 0; i < size; i++) {
    err_sm += (B[i] - anssm[i]) * (B[i] - anssm[i]);
  }
  int j;
  for (i = 0; i < m; i++) {
    for (j = 0; j < m; j++) {
      printf("%lg\t%lg\n", B[i + m * j], anssm[j + i * m]);
    }
  }
  err_m = pow(err_m / size, .5);
  err_v = pow(err_v / m, .5);
  err_s = pow(err_s / m, .5);
  err_sm = pow(err_sm / m, .5);
  printf("Matmat Error: %.5e\n", err_m);
  printf("Matvec Error: %.5e\n", err_v);
  printf("Solve Error: %.5e\n", err_s);
  printf("3 Solve Error: %.5e\n", err_sm);
  free(A);
  free(B);
  free(C);
  free(D);
  free(E);
  free(ansm);
  free(ansv);
  free(anss);
  free(anssm);
  return;
}


x86 assembly (clang, -O0):
<test_2>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
movl   $0x3,-0x4(%rbp)
movl   $0x9,-0x8(%rbp)
movslq -0x8(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x10(%rbp)
movslq -0x8(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x18(%rbp)
movslq -0x8(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x20(%rbp)
movslq -0x8(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x28(%rbp)
movslq -0x8(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x30(%rbp)
movslq -0x4(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x38(%rbp)
movslq -0x4(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x40(%rbp)
movslq -0x4(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0x4(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x50(%rbp)
lea    0xdad(%rip),%rdi
lea    0xdb0(%rip),%rsi
call   1080 <fopen@plt>
mov    %rax,-0x68(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x8(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    $0x8,%esi
call   1050 <fread@plt>
mov    -0x18(%rbp),%rdi
mov    -0x8(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    $0x8,%esi
call   1050 <fread@plt>
mov    -0x20(%rbp),%rdi
mov    -0x8(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    $0x8,%esi
call   1050 <fread@plt>
mov    -0x38(%rbp),%rdi
mov    -0x4(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    $0x8,%esi
call   1050 <fread@plt>
mov    -0x40(%rbp),%rdi
mov    -0x4(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    $0x8,%esi
call   1050 <fread@plt>
lea    -0x60(%rbp),%rdi
mov    -0x68(%rbp),%rcx
mov    $0x8,%esi
mov    $0x2,%edx
call   1050 <fread@plt>
mov    -0x28(%rbp),%rdi
mov    -0x8(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    $0x8,%esi
call   1050 <fread@plt>
mov    -0x48(%rbp),%rdi
mov    -0x4(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    $0x8,%esi
call   1050 <fread@plt>
mov    -0x50(%rbp),%rdi
mov    -0x4(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    $0x8,%esi
call   1050 <fread@plt>
mov    -0x30(%rbp),%rdi
mov    -0x8(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    $0x8,%esi
call   1050 <fread@plt>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
movsd  -0x60(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
mov    -0x4(%rbp),%ecx
call   10a0 <matmat@plt>
mov    -0x10(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x40(%rbp),%rdx
movsd  -0x60(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
mov    -0x4(%rbp),%ecx
call   10b0 <matvec@plt>
mov    -0x10(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x4(%rbp),%edx
mov    $0x1,%ecx
call   1030 <solve@plt>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x4(%rbp),%edx
mov    -0x4(%rbp),%ecx
call   1030 <solve@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1430 <test_2+0x2a0>
mov    -0x20(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x6c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x6c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    13d0 <test_2+0x240>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1497 <test_2+0x307>
mov    -0x40(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x6c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
movslq -0x6c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1437 <test_2+0x2a7>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1504 <test_2+0x374>
mov    -0x38(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x6c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x50(%rbp),%rax
movslq -0x6c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    149e <test_2+0x30e>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1571 <test_2+0x3e1>
mov    -0x18(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x6c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq -0x6c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    150b <test_2+0x37b>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1608 <test_2+0x478>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15f5 <test_2+0x465>
mov    -0x18(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x4(%rbp),%edx
imul   -0x94(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x94(%rbp),%ecx
mov    -0x6c(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
lea    0xa3a(%rip),%rdi
mov    $0x2,%al
call   1060 <printf@plt>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    158e <test_2+0x3fe>
jmp    15fa <test_2+0x46a>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1578 <test_2+0x3e8>
movsd  -0x78(%rbp),%xmm0
cvtsi2sdl -0x8(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  0x9e2(%rip),%xmm1
call   1090 <pow@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  -0x80(%rbp),%xmm0
cvtsi2sdl -0x4(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  0x9c2(%rip),%xmm1
call   1090 <pow@plt>
movsd  %xmm0,-0x80(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
cvtsi2sdl -0x4(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  0x99f(%rip),%xmm1
call   1090 <pow@plt>
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
cvtsi2sdl -0x4(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  0x979(%rip),%xmm1
call   1090 <pow@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
lea    0x97d(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movsd  -0x80(%rbp),%xmm0
lea    0x97e(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movsd  -0x88(%rbp),%xmm0
ff
lea    0x97e(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movsd  -0x90(%rbp),%xmm0
ff
lea    0x966(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    -0x10(%rbp),%rdi
call   1040 <free@plt>
mov    -0x18(%rbp),%rdi
call   1040 <free@plt>
mov    -0x20(%rbp),%rdi
call   1040 <free@plt>
mov    -0x38(%rbp),%rdi
call   1040 <free@plt>
mov    -0x40(%rbp),%rdi
call   1040 <free@plt>
mov    -0x28(%rbp),%rdi
call   1040 <free@plt>
mov    -0x48(%rbp),%rdi
call   1040 <free@plt>
mov    -0x50(%rbp),%rdi
call   1040 <free@plt>
mov    -0x30(%rbp),%rdi
call   1040 <free@plt>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    $0x48,%edi
call   1070 <malloc@plt>
mov    %rax,%r15
mov    $0x48,%edi
call   1070 <malloc@plt>
mov    %rax,%rbx
mov    $0x48,%edi
call   1070 <malloc@plt>
mov    %rax,0x30(%rsp)
mov    $0x48,%edi
call   1070 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    $0x48,%edi
call   1070 <malloc@plt>
mov    %rax,%r12
mov    $0x18,%edi
call   1070 <malloc@plt>
mov    %rax,%r13
mov    %rax,0x40(%rsp)
mov    $0x18,%edi
call   1070 <malloc@plt>
mov    %rax,%r14
mov    $0x18,%edi
call   1070 <malloc@plt>
mov    %rax,0x20(%rsp)
mov    $0x18,%edi
call   1070 <malloc@plt>
mov    %rax,0x38(%rsp)
lea    0xdf6(%rip),%rdi
lea    0xdf9(%rip),%rsi
call   1080 <fopen@plt>
mov    %rax,%rbp
mov    %r15,%rdi
mov    $0x8,%esi
mov    $0x9,%edx
mov    %rax,%rcx
call   1050 <fread@plt>
mov    %rbx,%rdi
mov    $0x8,%esi
mov    $0x9,%edx
mov    %rbp,%rcx
call   1050 <fread@plt>
mov    0x30(%rsp),%rdi
mov    $0x8,%esi
mov    $0x9,%edx
mov    %rbp,%rcx
call   1050 <fread@plt>
mov    %r13,%rdi
mov    $0x8,%esi
mov    $0x3,%edx
mov    %rbp,%rcx
call   1050 <fread@plt>
mov    %r14,%rdi
mov    %r14,0x48(%rsp)
mov    $0x8,%esi
mov    $0x3,%edx
mov    %rbp,%rcx
call   1050 <fread@plt>
lea    0xa0(%rsp),%rdi
mov    $0x8,%esi
mov    $0x2,%edx
mov    %rbp,%rcx
call   1050 <fread@plt>
mov    0x28(%rsp),%rdi
mov    $0x8,%esi
mov    $0x9,%edx
mov    %rbp,%rcx
call   1050 <fread@plt>
mov    0x20(%rsp),%rdi
mov    $0x8,%esi
mov    $0x3,%edx
mov    %rbp,%rcx
call   1050 <fread@plt>
mov    0x38(%rsp),%rdi
mov    $0x8,%esi
mov    $0x3,%edx
mov    %rbp,%rcx
call   1050 <fread@plt>
mov    %r12,%rdi
mov    $0x8,%esi
mov    $0x9,%edx
mov    %rbp,%rcx
call   1050 <fread@plt>
movsd  0xa0(%rsp),%xmm0
movsd  %xmm0,(%rsp)
movsd  0xa8(%rsp),%xmm1
movsd  %xmm1,0x8(%rsp)
mov    %r15,0x98(%rsp)
mov    %r15,%rdi
mov    %rbx,%rsi
mov    0x30(%rsp),%r13
mov    %r13,%rdx
mov    $0x3,%ecx
call   10a0 <matmat@plt>
mov    %r15,%rdi
mov    0x40(%rsp),%rbp
mov    %rbp,%rsi
mov    %r14,%rdx
movsd  (%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
mov    $0x3,%ecx
call   10b0 <matvec@plt>
mov    %r15,%rdi
mov    %rbp,%rsi
mov    $0x3,%edx
mov    $0x1,%ecx
call   1030 <solve@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    $0x3,%edx
mov    $0x3,%ecx
call   1030 <solve@plt>
movsd  0x0(%r13),%xmm0
movsd  0x8(%r13),%xmm5
mov    0x28(%rsp),%r14
subsd  (%r14),%xmm0
subsd  0x8(%r14),%xmm5
movsd  0x10(%r13),%xmm7
subsd  0x10(%r14),%xmm7
movsd  0x18(%r13),%xmm6
subsd  0x18(%r14),%xmm6
movsd  0x20(%r13),%xmm4
subsd  0x20(%r14),%xmm4
movsd  0x28(%r13),%xmm2
subsd  0x28(%r14),%xmm2
movsd  0x30(%r13),%xmm11
subsd  0x30(%r14),%xmm11
movsd  0x38(%r13),%xmm10
subsd  0x38(%r14),%xmm10
movsd  0x40(%r13),%xmm3
subsd  0x40(%r14),%xmm3
movsd  %xmm3,0x8(%rsp)
mov    0x48(%rsp),%rax
movsd  (%rax),%xmm3
movsd  0x8(%rax),%xmm8
mov    0x20(%rsp),%rcx
subsd  (%rcx),%xmm3
subsd  0x8(%rcx),%xmm8
movsd  0x10(%rax),%xmm9
subsd  0x10(%rcx),%xmm9
mulsd  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
mulsd  %xmm5,%xmm5
addsd  %xmm0,%xmm5
mulsd  %xmm7,%xmm7
addsd  %xmm5,%xmm7
mulsd  %xmm6,%xmm6
addsd  %xmm7,%xmm6
mulsd  %xmm4,%xmm4
addsd  %xmm6,%xmm4
mulsd  %xmm2,%xmm2
addsd  %xmm4,%xmm2
mulsd  %xmm11,%xmm11
addsd  %xmm2,%xmm11
mov    %rbp,%rax
movsd  0x0(%rbp),%xmm4
movsd  0x8(%rbp),%xmm2
mov    0x38(%rsp),%rbp
subsd  0x0(%rbp),%xmm4
subsd  0x8(%rbp),%xmm2
mulsd  %xmm10,%xmm10
movsd  0x10(%rax),%xmm5
subsd  0x10(%rbp),%xmm5
addsd  %xmm11,%xmm10
movsd  %xmm10,0x18(%rsp)
mulsd  %xmm3,%xmm3
xorpd  %xmm6,%xmm6
addsd  %xmm6,%xmm3
mulsd  %xmm8,%xmm8
addsd  %xmm3,%xmm8
movsd  0x8(%rbx),%xmm0
subsd  0x8(%r12),%xmm0
movsd  %xmm0,0x60(%rsp)
mulsd  %xmm9,%xmm9
movsd  0x10(%rbx),%xmm0
subsd  0x10(%r12),%xmm0
movsd  %xmm0,0x68(%rsp)
addsd  %xmm8,%xmm9
movsd  %xmm9,0x10(%rsp)
movsd  0x18(%rbx),%xmm0
subsd  0x18(%r12),%xmm0
movsd  %xmm0,0x70(%rsp)
movsd  (%r12),%xmm1
movsd  0x20(%rbx),%xmm0
subsd  0x20(%r12),%xmm0
movsd  %xmm0,0x78(%rsp)
movsd  (%rbx),%xmm0
movapd %xmm0,%xmm7
movsd  0x28(%rbx),%xmm3
subsd  0x28(%r12),%xmm3
movsd  %xmm3,0x80(%rsp)
subsd  %xmm1,%xmm7
movsd  %xmm7,0x50(%rsp)
movsd  0x30(%rbx),%xmm3
subsd  0x30(%r12),%xmm3
movsd  %xmm3,0x88(%rsp)
mulsd  %xmm4,%xmm4
addsd  %xmm6,%xmm4
mulsd  %xmm2,%xmm2
addsd  %xmm4,%xmm2
movsd  0x38(%rbx),%xmm3
subsd  0x38(%r12),%xmm3
movsd  %xmm3,0x58(%rsp)
mulsd  %xmm5,%xmm5
addsd  %xmm2,%xmm5
movsd  %xmm5,0x90(%rsp)
movsd  0x40(%rbx),%xmm2
subsd  0x40(%r12),%xmm2
movsd  %xmm2,(%rsp)
lea    0xa74(%rip),%r15
mov    %r15,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x18(%rbx),%xmm0
movsd  0x8(%r12),%xmm1
mov    %r15,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x30(%rbx),%xmm0
movsd  0x10(%r12),%xmm1
mov    %r15,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x8(%rbx),%xmm0
movsd  0x18(%r12),%xmm1
mov    %r15,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x20(%rbx),%xmm0
movsd  0x20(%r12),%xmm1
mov    %r15,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x38(%rbx),%xmm0
movsd  0x28(%r12),%xmm1
mov    %r15,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x10(%rbx),%xmm0
movsd  0x30(%r12),%xmm1
mov    %r15,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x28(%rbx),%xmm0
movsd  0x38(%r12),%xmm1
mov    %r15,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x40(%rbx),%xmm0
movsd  0x40(%r12),%xmm1
mov    %r15,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x50(%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  0x994(%rip),%xmm0
movapd %xmm0,%xmm1
movsd  0x60(%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x68(%rsp),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x70(%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm0,%xmm1
movsd  0x78(%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm0,%xmm1
movsd  0x80(%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm0,%xmm1
movsd  0x88(%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x58(%rsp),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  (%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
movsd  0x8(%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  0x18(%rsp),%xmm0
divsd  0x8da(%rip),%xmm0
movsd  0x8da(%rip),%xmm1
call   1090 <pow@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%rsp),%xmm0
divsd  0x8c9(%rip),%xmm0
movsd  0x8b9(%rip),%xmm1
call   1090 <pow@plt>
movsd  %xmm0,0x18(%rsp)
movsd  0x90(%rsp),%xmm0
divsd  0x8a5(%rip),%xmm0
movsd  0x895(%rip),%xmm1
call   1090 <pow@plt>
movsd  %xmm0,0x10(%rsp)
movsd  (%rsp),%xmm0
divsd  0x885(%rip),%xmm0
movsd  0x875(%rip),%xmm1
call   1090 <pow@plt>
movsd  %xmm0,(%rsp)
lea    0x891(%rip),%rdi
movsd  0x8(%rsp),%xmm0
mov    $0x1,%al
call   1060 <printf@plt>
lea    0x891(%rip),%rdi
movsd  0x18(%rsp),%xmm0
mov    $0x1,%al
call   1060 <printf@plt>
lea    0x893(%rip),%rdi
movsd  0x10(%rsp),%xmm0
mov    $0x1,%al
call   1060 <printf@plt>
lea    0x87d(%rip),%rdi
movsd  (%rsp),%xmm0
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x98(%rsp),%rdi
call   1040 <free@plt>
mov    %rbx,%rdi
call   1040 <free@plt>
mov    %r13,%rdi
call   1040 <free@plt>
mov    0x40(%rsp),%rdi
call   1040 <free@plt>
mov    0x48(%rsp),%rdi
call   1040 <free@plt>
mov    %r14,%rdi
call   1040 <free@plt>
mov    0x20(%rsp),%rdi
call   1040 <free@plt>
mov    %rbp,%rdi
call   1040 <free@plt>
mov    %r12,%rdi
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <free@plt>

LLVM IR (-O0):
@.str = [10 x i8] c"input.dat\00"
@.str.1 = [2 x i8] c"r\00"
@.str.2 = [9 x i8] c"%lg\09%lg\0A\00"
@.str.3 = [20 x i8] c"Matmat Error: %.5e\0A\00"
@.str.4 = [20 x i8] c"Matvec Error: %.5e\0A\00"
@.str.5 = [19 x i8] c"Solve Error: %.5e\0A\00"
@.str.6 = [21 x i8] c"3 Solve Error: %.5e\0A\00"
define void @test_2() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca double*
%4 = alloca double*
%5 = alloca double*
%6 = alloca double*
%7 = alloca double*
%8 = alloca double*
%9 = alloca double*
%10 = alloca double*
%11 = alloca double*
%12 = alloca [2 x double]
%13 = alloca i32*
%14 = alloca i32
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca i32
store i32 3, i32* %1
store i32 9, i32* %2
%20 = load i32, i32* %2
%21 = sext i32 %20 to i64
%22 = mul i64 8, %21
%23 = trunc i64 %22 to i32
%24 = call i64 @malloc(i32 %23)
%25 = inttoptr i64 %24 to double*
store double* %25, double** %3
%26 = load i32, i32* %2
%27 = sext i32 %26 to i64
%28 = mul i64 8, %27
%29 = trunc i64 %28 to i32
%30 = call i64 @malloc(i32 %29)
%31 = inttoptr i64 %30 to double*
store double* %31, double** %4
%32 = load i32, i32* %2
%33 = sext i32 %32 to i64
%34 = mul i64 8, %33
%35 = trunc i64 %34 to i32
%36 = call i64 @malloc(i32 %35)
%37 = inttoptr i64 %36 to double*
store double* %37, double** %5
%38 = load i32, i32* %2
%39 = sext i32 %38 to i64
%40 = mul i64 8, %39
%41 = trunc i64 %40 to i32
%42 = call i64 @malloc(i32 %41)
%43 = inttoptr i64 %42 to double*
store double* %43, double** %6
%44 = load i32, i32* %2
%45 = sext i32 %44 to i64
%46 = mul i64 8, %45
%47 = trunc i64 %46 to i32
%48 = call i64 @malloc(i32 %47)
%49 = inttoptr i64 %48 to double*
store double* %49, double** %7
%50 = load i32, i32* %1
%51 = sext i32 %50 to i64
%52 = mul i64 8, %51
%53 = trunc i64 %52 to i32
%54 = call i64 @malloc(i32 %53)
%55 = inttoptr i64 %54 to double*
store double* %55, double** %8
%56 = load i32, i32* %1
%57 = sext i32 %56 to i64
%58 = mul i64 8, %57
%59 = trunc i64 %58 to i32
%60 = call i64 @malloc(i32 %59)
%61 = inttoptr i64 %60 to double*
store double* %61, double** %9
%62 = load i32, i32* %1
%63 = sext i32 %62 to i64
%64 = mul i64 8, %63
%65 = trunc i64 %64 to i32
%66 = call i64 @malloc(i32 %65)
%67 = inttoptr i64 %66 to double*
store double* %67, double** %10
%68 = load i32, i32* %1
%69 = sext i32 %68 to i64
%70 = mul i64 8, %69
%71 = trunc i64 %70 to i32
%72 = call i64 @malloc(i32 %71)
%73 = inttoptr i64 %72 to double*
store double* %73, double** %11
%74 = call i32* @fopen(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i32* %74, i32** %13
%75 = load double*, double** %3
%76 = load i32, i32* %2
%77 = load i32*, i32** %13
%78 = call i32 @fread(double* %75, i32 8, i32 %76, i32* %77)
%79 = load double*, double** %4
%80 = load i32, i32* %2
%81 = load i32*, i32** %13
%82 = call i32 @fread(double* %79, i32 8, i32 %80, i32* %81)
%83 = load double*, double** %5
%84 = load i32, i32* %2
%85 = load i32*, i32** %13
%86 = call i32 @fread(double* %83, i32 8, i32 %84, i32* %85)
%87 = load double*, double** %8
%88 = load i32, i32* %1
%89 = load i32*, i32** %13
%90 = call i32 @fread(double* %87, i32 8, i32 %88, i32* %89)
%91 = load double*, double** %9
%92 = load i32, i32* %1
%93 = load i32*, i32** %13
%94 = call i32 @fread(double* %91, i32 8, i32 %92, i32* %93)
%95 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 0
%96 = load i32*, i32** %13
%97 = call i32 @fread(double* %95, i32 8, i32 2, i32* %96)
%98 = load double*, double** %6
%99 = load i32, i32* %2
%100 = load i32*, i32** %13
%101 = call i32 @fread(double* %98, i32 8, i32 %99, i32* %100)
%102 = load double*, double** %10
%103 = load i32, i32* %1
%104 = load i32*, i32** %13
%105 = call i32 @fread(double* %102, i32 8, i32 %103, i32* %104)
%106 = load double*, double** %11
%107 = load i32, i32* %1
%108 = load i32*, i32** %13
%109 = call i32 @fread(double* %106, i32 8, i32 %107, i32* %108)
%110 = load double*, double** %7
%111 = load i32, i32* %2
%112 = load i32*, i32** %13
%113 = call i32 @fread(double* %110, i32 8, i32 %111, i32* %112)
%114 = load double*, double** %3
%115 = load double*, double** %4
%116 = load double*, double** %5
%117 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 0
%118 = load double, double* %117
%119 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 1
%120 = load double, double* %119
%121 = load i32, i32* %1
%122 = call i32 @matmat(double* %114, double* %115, double* %116, double %118, double %120, i32 %121)
%123 = load double*, double** %3
%124 = load double*, double** %8
%125 = load double*, double** %9
%126 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 0
%127 = load double, double* %126
%128 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 1
%129 = load double, double* %128
%130 = load i32, i32* %1
%131 = call i32 @matvec(double* %123, double* %124, double* %125, double %127, double %129, i32 %130)
%132 = load double*, double** %3
%133 = load double*, double** %8
%134 = load i32, i32* %1
%135 = call i32 @solve(double* %132, double* %133, i32 %134, i32 1)
%136 = load double*, double** %3
%137 = load double*, double** %4
%138 = load i32, i32* %1
%139 = load i32, i32* %1
%140 = call i32 @solve(double* %136, double* %137, i32 %138, i32 %139)
store double 0.000000e+00, double* %15
store double 0.000000e+00, double* %16
store double 0.000000e+00, double* %17
store double 0.000000e+00, double* %18
store i32 0, i32* %14
br label %141
141: ; preds = %170, %0
%142 = load i32, i32* %14
%143 = load i32, i32* %2
%144 = icmp slt i32 %142, %143
br i1 %144, label %145, label %173
145: ; preds = %141
%146 = load double*, double** %5
%147 = load i32, i32* %14
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds double, double* %146, i64 %148
%150 = load double, double* %149
%151 = load double*, double** %6
%152 = load i32, i32* %14
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds double, double* %151, i64 %153
%155 = load double, double* %154
%156 = fsub double %150, %155
%157 = load double*, double** %5
%158 = load i32, i32* %14
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds double, double* %157, i64 %159
%161 = load double, double* %160
%162 = load double*, double** %6
%163 = load i32, i32* %14
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds double, double* %162, i64 %164
%166 = load double, double* %165
%167 = fsub double %161, %166
%168 = load double, double* %15
%169 = call double @llvm.fmuladd.f64(double %156, double %167, double %168)
store double %169, double* %15
br label %170
170: ; preds = %145
%171 = load i32, i32* %14
%172 = add nsw i32 %171, 1
store i32 %172, i32* %14
br label %141
173: ; preds = %141
store i32 0, i32* %14
br label %174
174: ; preds = %203, %173
%175 = load i32, i32* %14
%176 = load i32, i32* %1
%177 = icmp slt i32 %175, %176
br i1 %177, label %178, label %206
178: ; preds = %174
%179 = load double*, double** %9
%180 = load i32, i32* %14
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds double, double* %179, i64 %181
%183 = load double, double* %182
%184 = load double*, double** %10
%185 = load i32, i32* %14
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds double, double* %184, i64 %186
%188 = load double, double* %187
%189 = fsub double %183, %188
%190 = load double*, double** %9
%191 = load i32, i32* %14
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds double, double* %190, i64 %192
%194 = load double, double* %193
%195 = load double*, double** %10
%196 = load i32, i32* %14
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds double, double* %195, i64 %197
%199 = load double, double* %198
%200 = fsub double %194, %199
%201 = load double, double* %16
%202 = call double @llvm.fmuladd.f64(double %189, double %200, double %201)
store double %202, double* %16
br label %203
203: ; preds = %178
%204 = load i32, i32* %14
%205 = add nsw i32 %204, 1
store i32 %205, i32* %14
br label %174
206: ; preds = %174
store i32 0, i32* %14
br label %207
207: ; preds = %236, %206
%208 = load i32, i32* %14
%209 = load i32, i32* %1
%210 = icmp slt i32 %208, %209
br i1 %210, label %211, label %239
211: ; preds = %207
%212 = load double*, double** %8
%213 = load i32, i32* %14
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds double, double* %212, i64 %214
%216 = load double, double* %215
%217 = load double*, double** %11
%218 = load i32, i32* %14
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds double, double* %217, i64 %219
%221 = load double, double* %220
%222 = fsub double %216, %221
%223 = load double*, double** %8
%224 = load i32, i32* %14
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds double, double* %223, i64 %225
%227 = load double, double* %226
%228 = load double*, double** %11
%229 = load i32, i32* %14
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds double, double* %228, i64 %230
%232 = load double, double* %231
%233 = fsub double %227, %232
%234 = load double, double* %17
%235 = call double @llvm.fmuladd.f64(double %222, double %233, double %234)
store double %235, double* %17
br label %236
236: ; preds = %211
%237 = load i32, i32* %14
%238 = add nsw i32 %237, 1
store i32 %238, i32* %14
br label %207
239: ; preds = %207
store i32 0, i32* %14
br label %240
240: ; preds = %269, %239
%241 = load i32, i32* %14
%242 = load i32, i32* %2
%243 = icmp slt i32 %241, %242
br i1 %243, label %244, label %272
244: ; preds = %240
%245 = load double*, double** %4
%246 = load i32, i32* %14
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds double, double* %245, i64 %247
%249 = load double, double* %248
%250 = load double*, double** %7
%251 = load i32, i32* %14
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds double, double* %250, i64 %252
%254 = load double, double* %253
%255 = fsub double %249, %254
%256 = load double*, double** %4
%257 = load i32, i32* %14
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds double, double* %256, i64 %258
%260 = load double, double* %259
%261 = load double*, double** %7
%262 = load i32, i32* %14
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds double, double* %261, i64 %263
%265 = load double, double* %264
%266 = fsub double %260, %265
%267 = load double, double* %18
%268 = call double @llvm.fmuladd.f64(double %255, double %266, double %267)
store double %268, double* %18
br label %269
269: ; preds = %244
%270 = load i32, i32* %14
%271 = add nsw i32 %270, 1
store i32 %271, i32* %14
br label %240
272: ; preds = %240
store i32 0, i32* %14
br label %273
273: ; preds = %306, %272
%274 = load i32, i32* %14
%275 = load i32, i32* %1
%276 = icmp slt i32 %274, %275
br i1 %276, label %277, label %309
277: ; preds = %273
store i32 0, i32* %19
br label %278
278: ; preds = %302, %277
%279 = load i32, i32* %19
%280 = load i32, i32* %1
%281 = icmp slt i32 %279, %280
br i1 %281, label %282, label %305
282: ; preds = %278
%283 = load double*, double** %4
%284 = load i32, i32* %14
%285 = load i32, i32* %1
%286 = load i32, i32* %19
%287 = mul nsw i32 %285, %286
%288 = add nsw i32 %284, %287
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds double, double* %283, i64 %289
%291 = load double, double* %290
%292 = load double*, double** %7
%293 = load i32, i32* %19
%294 = load i32, i32* %14
%295 = load i32, i32* %1
%296 = mul nsw i32 %294, %295
%297 = add nsw i32 %293, %296
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds double, double* %292, i64 %298
%300 = load double, double* %299
%301 = call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), double %291, double %300)
br label %302
302: ; preds = %282
%303 = load i32, i32* %19
%304 = add nsw i32 %303, 1
store i32 %304, i32* %19
br label %278
305: ; preds = %278
br label %306
306: ; preds = %305
%307 = load i32, i32* %14
%308 = add nsw i32 %307, 1
store i32 %308, i32* %14
br label %273
309: ; preds = %273
%310 = load double, double* %15
%311 = load i32, i32* %2
%312 = sitofp i32 %311 to double
%313 = fdiv double %310, %312
%314 = call double @pow(double %313, double 5.000000e-01)
store double %314, double* %15
%315 = load double, double* %16
%316 = load i32, i32* %1
%317 = sitofp i32 %316 to double
%318 = fdiv double %315, %317
%319 = call double @pow(double %318, double 5.000000e-01)
store double %319, double* %16
%320 = load double, double* %17
%321 = load i32, i32* %1
%322 = sitofp i32 %321 to double
%323 = fdiv double %320, %322
%324 = call double @pow(double %323, double 5.000000e-01)
store double %324, double* %17
%325 = load double, double* %18
%326 = load i32, i32* %1
%327 = sitofp i32 %326 to double
%328 = fdiv double %325, %327
%329 = call double @pow(double %328, double 5.000000e-01)
store double %329, double* %18
%330 = load double, double* %15
%331 = call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.3, i64 0, i64 0), double %330)
%332 = load double, double* %16
%333 = call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.4, i64 0, i64 0), double %332)
%334 = load double, double* %17
%335 = call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.5, i64 0, i64 0), double %334)
%336 = load double, double* %18
%337 = call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.6, i64 0, i64 0), double %336)
%338 = load double*, double** %3
%339 = call i32 @free(double* %338)
%340 = load double*, double** %4
%341 = call i32 @free(double* %340)
%342 = load double*, double** %5
%343 = call i32 @free(double* %342)
%344 = load double*, double** %8
%345 = call i32 @free(double* %344)
%346 = load double*, double** %9
%347 = call i32 @free(double* %346)
%348 = load double*, double** %6
%349 = call i32 @free(double* %348)
%350 = load double*, double** %10
%351 = call i32 @free(double* %350)
%352 = load double*, double** %11
%353 = call i32 @free(double* %352)
%354 = load double*, double** %7
%355 = call i32 @free(double* %354)
ret void
}

LLVM IR (-O2):
@.str = [10 x i8] c"input.dat\00"
@.str.1 = [2 x i8] c"r\00"
@.str.2 = [9 x i8] c"%lg\09%lg\0A\00"
@.str.3 = [20 x i8] c"Matmat Error: %.5e\0A\00"
@.str.4 = [20 x i8] c"Matvec Error: %.5e\0A\00"
@.str.5 = [19 x i8] c"Solve Error: %.5e\0A\00"
@.str.6 = [21 x i8] c"3 Solve Error: %.5e\0A\00"
define void @test_2() {
%1 = alloca [2 x double]
%2 = tail call i64 @malloc(i32 72)
%3 = inttoptr i64 %2 to double*
%4 = tail call i64 @malloc(i32 72)
%5 = inttoptr i64 %4 to double*
%6 = tail call i64 @malloc(i32 72)
%7 = inttoptr i64 %6 to double*
%8 = tail call i64 @malloc(i32 72)
%9 = inttoptr i64 %8 to double*
%10 = tail call i64 @malloc(i32 72)
%11 = inttoptr i64 %10 to double*
%12 = tail call i64 @malloc(i32 24)
%13 = inttoptr i64 %12 to double*
%14 = tail call i64 @malloc(i32 24)
%15 = inttoptr i64 %14 to double*
%16 = tail call i64 @malloc(i32 24)
%17 = inttoptr i64 %16 to double*
%18 = tail call i64 @malloc(i32 24)
%19 = inttoptr i64 %18 to double*
%20 = bitcast [2 x double]* %1 to i8*
%21 = tail call i32* @fopen(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%22 = tail call i32 @fread(double* %3, i32 8, i32 9, i32* %21)
%23 = tail call i32 @fread(double* %5, i32 8, i32 9, i32* %21)
%24 = tail call i32 @fread(double* %7, i32 8, i32 9, i32* %21)
%25 = tail call i32 @fread(double* %13, i32 8, i32 3, i32* %21)
%26 = tail call i32 @fread(double* %15, i32 8, i32 3, i32* %21)
%27 = getelementptr inbounds [2 x double], [2 x double]* %1, i64 0, i64 0
%28 = call i32 @fread(double* %27, i32 8, i32 2, i32* %21)
%29 = tail call i32 @fread(double* %9, i32 8, i32 9, i32* %21)
%30 = tail call i32 @fread(double* %17, i32 8, i32 3, i32* %21)
%31 = tail call i32 @fread(double* %19, i32 8, i32 3, i32* %21)
%32 = tail call i32 @fread(double* %11, i32 8, i32 9, i32* %21)
%33 = load double, double* %27
%34 = getelementptr inbounds [2 x double], [2 x double]* %1, i64 0, i64 1
%35 = load double, double* %34
%36 = tail call i32 @matmat(double* %3, double* %5, double* %7, double %33, double %35, i32 3)
%37 = tail call i32 @matvec(double* %3, double* %13, double* %15, double %33, double %35, i32 3)
%38 = tail call i32 @solve(double* %3, double* %13, i32 3, i32 1)
%39 = tail call i32 @solve(double* %3, double* %5, i32 3, i32 3)
%40 = load double, double* %7
%41 = load double, double* %9
%42 = fsub double %40, %41
%43 = getelementptr inbounds double, double* %7, i64 1
%44 = load double, double* %43
%45 = getelementptr inbounds double, double* %9, i64 1
%46 = load double, double* %45
%47 = fsub double %44, %46
%48 = getelementptr inbounds double, double* %7, i64 2
%49 = load double, double* %48
%50 = getelementptr inbounds double, double* %9, i64 2
%51 = load double, double* %50
%52 = fsub double %49, %51
%53 = getelementptr inbounds double, double* %7, i64 3
%54 = load double, double* %53
%55 = getelementptr inbounds double, double* %9, i64 3
%56 = load double, double* %55
%57 = fsub double %54, %56
%58 = getelementptr inbounds double, double* %7, i64 4
%59 = load double, double* %58
%60 = getelementptr inbounds double, double* %9, i64 4
%61 = load double, double* %60
%62 = fsub double %59, %61
%63 = getelementptr inbounds double, double* %7, i64 5
%64 = load double, double* %63
%65 = getelementptr inbounds double, double* %9, i64 5
%66 = load double, double* %65
%67 = fsub double %64, %66
%68 = getelementptr inbounds double, double* %7, i64 6
%69 = load double, double* %68
%70 = getelementptr inbounds double, double* %9, i64 6
%71 = load double, double* %70
%72 = fsub double %69, %71
%73 = getelementptr inbounds double, double* %7, i64 7
%74 = load double, double* %73
%75 = getelementptr inbounds double, double* %9, i64 7
%76 = load double, double* %75
%77 = fsub double %74, %76
%78 = getelementptr inbounds double, double* %7, i64 8
%79 = load double, double* %78
%80 = getelementptr inbounds double, double* %9, i64 8
%81 = load double, double* %80
%82 = fsub double %79, %81
%83 = load double, double* %15
%84 = load double, double* %17
%85 = fsub double %83, %84
%86 = getelementptr inbounds double, double* %15, i64 1
%87 = load double, double* %86
%88 = getelementptr inbounds double, double* %17, i64 1
%89 = load double, double* %88
%90 = fsub double %87, %89
%91 = getelementptr inbounds double, double* %15, i64 2
%92 = load double, double* %91
%93 = getelementptr inbounds double, double* %17, i64 2
%94 = load double, double* %93
%95 = fsub double %92, %94
%96 = tail call double @llvm.fmuladd.f64(double %42, double %42, double 0.000000e+00)
%97 = tail call double @llvm.fmuladd.f64(double %47, double %47, double %96)
%98 = tail call double @llvm.fmuladd.f64(double %52, double %52, double %97)
%99 = tail call double @llvm.fmuladd.f64(double %57, double %57, double %98)
%100 = tail call double @llvm.fmuladd.f64(double %62, double %62, double %99)
%101 = tail call double @llvm.fmuladd.f64(double %67, double %67, double %100)
%102 = tail call double @llvm.fmuladd.f64(double %72, double %72, double %101)
%103 = tail call double @llvm.fmuladd.f64(double %77, double %77, double %102)
%104 = load double, double* %13
%105 = load double, double* %19
%106 = fsub double %104, %105
%107 = getelementptr inbounds double, double* %13, i64 1
%108 = load double, double* %107
%109 = getelementptr inbounds double, double* %19, i64 1
%110 = load double, double* %109
%111 = fsub double %108, %110
%112 = getelementptr inbounds double, double* %13, i64 2
%113 = load double, double* %112
%114 = getelementptr inbounds double, double* %19, i64 2
%115 = load double, double* %114
%116 = fsub double %113, %115
%117 = tail call double @llvm.fmuladd.f64(double %85, double %85, double 0.000000e+00)
%118 = tail call double @llvm.fmuladd.f64(double %90, double %90, double %117)
%119 = tail call double @llvm.fmuladd.f64(double %95, double %95, double %118)
%120 = load double, double* %5
%121 = load double, double* %11
%122 = fsub double %120, %121
%123 = getelementptr inbounds double, double* %5, i64 1
%124 = load double, double* %123
%125 = getelementptr inbounds double, double* %11, i64 1
%126 = load double, double* %125
%127 = fsub double %124, %126
%128 = getelementptr inbounds double, double* %5, i64 2
%129 = load double, double* %128
%130 = getelementptr inbounds double, double* %11, i64 2
%131 = load double, double* %130
%132 = fsub double %129, %131
%133 = getelementptr inbounds double, double* %5, i64 3
%134 = load double, double* %133
%135 = getelementptr inbounds double, double* %11, i64 3
%136 = load double, double* %135
%137 = fsub double %134, %136
%138 = getelementptr inbounds double, double* %5, i64 4
%139 = load double, double* %138
%140 = getelementptr inbounds double, double* %11, i64 4
%141 = load double, double* %140
%142 = fsub double %139, %141
%143 = getelementptr inbounds double, double* %5, i64 5
%144 = load double, double* %143
%145 = getelementptr inbounds double, double* %11, i64 5
%146 = load double, double* %145
%147 = fsub double %144, %146
%148 = getelementptr inbounds double, double* %5, i64 6
%149 = load double, double* %148
%150 = getelementptr inbounds double, double* %11, i64 6
%151 = load double, double* %150
%152 = fsub double %149, %151
%153 = getelementptr inbounds double, double* %5, i64 7
%154 = load double, double* %153
%155 = getelementptr inbounds double, double* %11, i64 7
%156 = load double, double* %155
%157 = fsub double %154, %156
%158 = getelementptr inbounds double, double* %5, i64 8
%159 = load double, double* %158
%160 = getelementptr inbounds double, double* %11, i64 8
%161 = load double, double* %160
%162 = fsub double %159, %161
%163 = tail call double @llvm.fmuladd.f64(double %106, double %106, double 0.000000e+00)
%164 = tail call double @llvm.fmuladd.f64(double %111, double %111, double %163)
%165 = tail call double @llvm.fmuladd.f64(double %116, double %116, double %164)
%166 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), double %120, double %121)
%167 = load double, double* %133
%168 = load double, double* %125
%169 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), double %167, double %168)
%170 = load double, double* %148
%171 = load double, double* %130
%172 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), double %170, double %171)
%173 = load double, double* %123
%174 = load double, double* %135
%175 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), double %173, double %174)
%176 = load double, double* %138
%177 = load double, double* %140
%178 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), double %176, double %177)
%179 = load double, double* %153
%180 = load double, double* %145
%181 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), double %179, double %180)
%182 = load double, double* %128
%183 = load double, double* %150
%184 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), double %182, double %183)
%185 = load double, double* %143
%186 = load double, double* %155
%187 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), double %185, double %186)
%188 = load double, double* %158
%189 = load double, double* %160
%190 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), double %188, double %189)
%191 = tail call double @llvm.fmuladd.f64(double %122, double %122, double 0.000000e+00)
%192 = tail call double @llvm.fmuladd.f64(double %127, double %127, double %191)
%193 = tail call double @llvm.fmuladd.f64(double %132, double %132, double %192)
%194 = tail call double @llvm.fmuladd.f64(double %137, double %137, double %193)
%195 = tail call double @llvm.fmuladd.f64(double %142, double %142, double %194)
%196 = tail call double @llvm.fmuladd.f64(double %147, double %147, double %195)
%197 = tail call double @llvm.fmuladd.f64(double %152, double %152, double %196)
%198 = tail call double @llvm.fmuladd.f64(double %157, double %157, double %197)
%199 = tail call double @llvm.fmuladd.f64(double %162, double %162, double %198)
%200 = tail call double @llvm.fmuladd.f64(double %82, double %82, double %103)
%201 = fdiv double %200, 9.000000e+00
%202 = tail call double @pow(double %201, double 5.000000e-01)
%203 = fdiv double %119, 3.000000e+00
%204 = tail call double @pow(double %203, double 5.000000e-01)
%205 = fdiv double %165, 3.000000e+00
%206 = tail call double @pow(double %205, double 5.000000e-01)
%207 = fdiv double %199, 3.000000e+00
%208 = tail call double @pow(double %207, double 5.000000e-01)
%209 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.3, i64 0, i64 0), double %202)
%210 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.4, i64 0, i64 0), double %204)
%211 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.5, i64 0, i64 0), double %206)
%212 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.6, i64 0, i64 0), double %208)
%213 = tail call i32 @free(double* %3)
%214 = tail call i32 @free(double* %5)
%215 = tail call i32 @free(double* %7)
%216 = tail call i32 @free(double* %13)
%217 = tail call i32 @free(double* %15)
%218 = tail call i32 @free(double* %9)
%219 = tail call i32 @free(double* %17)
%220 = tail call i32 @free(double* %19)
%221 = tail call i32 @free(double* %11)
ret void
}