#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*/ gauss1(double *, double *, int);
int /*<<< orphan*/ memset(double *, int /*<<< orphan*/, int);
int /*<<< orphan*/ print_matrix(char *, double *, int, int);
void ctm_fitting(double *xy, int cnt, double *coeff_return) {
  int i;
  double abc[3], def[3];
  double ata[9], atx[3], aty[3];
  memset(ata, 0, sizeof ata);
  ;
  memset(atx, 0, sizeof atx);
  ;
  memset(aty, 0, sizeof aty);
  ;
  memset(def, 0, sizeof def);
  ;
  memset(abc, 0, sizeof abc);
  ;
  print_matrix("XY", xy, cnt, 4);
  for (i = 0; i < cnt; i++) {
    double *xy1 = xy + 4 * i;
    ata[0] += xy1[0] * xy1[0];
    ata[1] += xy1[0] * xy1[1];
    ata[2] += xy1[0];
    ata[4] += xy1[1] * xy1[1];
    ata[5] += xy1[1];
    atx[0] += xy1[0] * xy1[2];
    atx[1] += xy1[1] * xy1[2];
    atx[2] += xy1[2];
    aty[0] += xy1[0] * xy1[3];
    aty[1] += xy1[1] * xy1[3];
    aty[2] += xy1[3];
  }
  ata[3] = ata[1];
  ata[6] = ata[2];
  ata[7] = ata[5];
  ata[8] = cnt;
  print_matrix("ata", ata, 3, 3);
  print_matrix("atx", atx, 3, 1);
  print_matrix("aty", aty, 3, 1);
  double bgauss1[4 * 3], bgauss2[4 * 3];
  for (i = 0; i < 3; i++) {
    double *b = bgauss1 + i * 4;
    double *a = ata + i * 3;
    double *x = atx + i;
    b[0] = a[0];
    b[1] = a[1];
    b[2] = a[2];
    b[3] = x[0];
  }
  for (i = 0; i < 3; i++) {
    double *b = bgauss2 + i * 4;
    double *a = ata + i * 3;
    double *x = aty + i;
    b[0] = a[0];
    b[1] = a[1];
    b[2] = a[2];
    b[3] = x[0];
  }
  print_matrix("ata\\atx", bgauss1, 3, 4);
  print_matrix("ata\\aty", bgauss2, 3, 4);
  gauss1(bgauss1, abc, 3);
  gauss1(bgauss2, def, 3);
  print_matrix("abc", abc, 3, 1);
  print_matrix("def", def, 3, 1);
  for (i = 0; i < 3; i++) {
    coeff_return[3 * 0 + i] = abc[i];
    coeff_return[3 * 1 + i] = def[i];
  }
  coeff_return[3 * 2 + 0] = 0;
  coeff_return[3 * 2 + 1] = 0;
  coeff_return[3 * 2 + 2] = 1;
}


x86 assembly (clang, -O0):
<ctm_fitting>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1f0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
lea    -0xb0(%rbp),%rdi
xor    %esi,%esi
mov    $0x48,%edx
call   1030 <memset@plt>
lea    -0xd0(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    -0x60(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    -0x40(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
mov    -0x8(%rbp),%rsi
mov    -0xc(%rbp),%edx
lea    0xe5b(%rip),%rdi
mov    $0x4,%ecx
call   1050 <print_matrix@plt>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13ad <ctm_fitting+0x27d>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    -0xf8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0xf8(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0xf8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0xf8(%rbp),%rax
movsd  0x8(%rax),%xmm2
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0xf8(%rbp),%rax
movsd  (%rax),%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0xf8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0xf8(%rbp),%rax
movsd  0x8(%rax),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0xf8(%rbp),%rax
movsd  0x8(%rax),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0xf8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0xf8(%rbp),%rax
movsd  0x10(%rax),%xmm2
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0xf8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0xf8(%rbp),%rax
movsd  0x10(%rax),%xmm2
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0xf8(%rbp),%rax
movsd  0x10(%rax),%xmm0
addsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0xf8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0xf8(%rbp),%rax
movsd  0x18(%rax),%xmm2
movsd  -0xf0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0xf8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0xf8(%rbp),%rax
movsd  0x18(%rax),%xmm2
movsd  -0xe8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0xf8(%rbp),%rax
movsd  0x18(%rax),%xmm0
addsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11be <ctm_fitting+0x8e>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
cvtsi2sdl -0xc(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
lea    -0xb0(%rbp),%rsi
lea    0xc1c(%rip),%rdi
mov    $0x3,%ecx
mov    %ecx,%edx
call   1050 <print_matrix@plt>
lea    -0xd0(%rbp),%rsi
lea    0xc0a(%rip),%rdi
mov    $0x3,%edx
mov    $0x1,%ecx
call   1050 <print_matrix@plt>
lea    -0xf0(%rbp),%rsi
lea    0xbf5(%rip),%rdi
mov    $0x3,%edx
mov    $0x1,%ecx
call   1050 <print_matrix@plt>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    1504 <ctm_fitting+0x3d4>
lea    -0x160(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x1c8(%rbp)
lea    -0xb0(%rbp),%rax
imul   $0x3,-0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x1d0(%rbp)
lea    -0xd0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x1d8(%rbp)
mov    -0x1d0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x1c8(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x1d0(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x1c8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x1d0(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x1c8(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x1d8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x1c8(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    143c <ctm_fitting+0x30c>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    15d3 <ctm_fitting+0x4a3>
lea    -0x1c0(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x1e0(%rbp)
lea    -0xb0(%rbp),%rax
imul   $0x3,-0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x1e8(%rbp)
lea    -0xf0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x1f0(%rbp)
mov    -0x1e8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x1e0(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x1e8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x1e0(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x1e8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x1e0(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x1f0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x1e0(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    150b <ctm_fitting+0x3db>
lea    -0x160(%rbp),%rsi
lea    0xa2e(%rip),%rdi
mov    $0x3,%edx
mov    $0x4,%ecx
call   1050 <print_matrix@plt>
lea    -0x1c0(%rbp),%rsi
lea    0xa19(%rip),%rdi
mov    $0x3,%edx
mov    $0x4,%ecx
call   1050 <print_matrix@plt>
lea    -0x160(%rbp),%rdi
lea    -0x40(%rbp),%rsi
mov    $0x3,%edx
call   1040 <gauss1@plt>
lea    -0x1c0(%rbp),%rdi
lea    -0x60(%rbp),%rsi
mov    $0x3,%edx
call   1040 <gauss1@plt>
lea    -0x40(%rbp),%rsi
lea    0x9dd(%rip),%rdi
mov    $0x3,%edx
mov    $0x1,%ecx
call   1050 <print_matrix@plt>
lea    -0x60(%rbp),%rsi
lea    0x9c7(%rip),%rdi
mov    $0x3,%edx
mov    $0x1,%ecx
call   1050 <print_matrix@plt>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    16c2 <ctm_fitting+0x592>
movslq -0x1c(%rbp),%rax
movsd  -0x40(%rbp,%rax,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x1c(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1672 <ctm_fitting+0x542>
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x30(%rax)
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x38(%rax)
mov    -0x18(%rbp),%rax
movsd  0x91a(%rip),%xmm0
movsd  %xmm0,0x40(%rax)
add    $0x1f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ctm_fitting>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x198,%rsp
mov    %rdx,%r14
mov    %esi,%ebp
mov    %rdi,%rbx
lea    0x40(%rsp),%rdi
xor    %esi,%esi
mov    $0x48,%edx
call   1030 <memset@plt>
lea    0x20(%rsp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
mov    %rsp,%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    0x90(%rsp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    0xb0(%rsp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    0xe5b(%rip),%rdi
mov    %rbx,%rsi
mov    %ebp,%edx
mov    $0x4,%ecx
call   1050 <print_matrix@plt>
test   %ebp,%ebp
jle    12c6 <ctm_fitting+0x196>
movapd 0x40(%rsp),%xmm6
movsd  0x50(%rsp),%xmm8
movsd  0x60(%rsp),%xmm4
movsd  0x68(%rsp),%xmm9
movapd 0x20(%rsp),%xmm7
movsd  0x30(%rsp),%xmm3
movapd (%rsp),%xmm2
movsd  0x10(%rsp),%xmm13
mov    %ebp,%eax
shl    $0x5,%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movapd %xmm2,%xmm11
movapd %xmm7,%xmm10
movapd %xmm6,%xmm12
movupd (%rbx,%rcx,1),%xmm7
movapd %xmm7,%xmm5
unpcklpd %xmm7,%xmm5
mulpd  %xmm7,%xmm5
movapd %xmm5,%xmm6
addpd  %xmm12,%xmm6
addsd  %xmm7,%xmm8
movsd  0x10(%rbx,%rcx,1),%xmm0
addsd  %xmm0,%xmm3
unpcklpd %xmm0,%xmm0
mulpd  %xmm7,%xmm0
movsd  0x18(%rbx,%rcx,1),%xmm1
addsd  %xmm1,%xmm13
unpcklpd %xmm1,%xmm1
mulpd  %xmm7,%xmm1
unpckhpd %xmm7,%xmm7
addsd  %xmm7,%xmm9
mulsd  %xmm7,%xmm7
addsd  %xmm7,%xmm4
movapd %xmm0,%xmm7
addpd  %xmm10,%xmm7
movapd %xmm1,%xmm2
addpd  %xmm11,%xmm2
add    $0x20,%rcx
cmp    %rcx,%rax
jne    1200 <ctm_fitting+0xd0>
addpd  %xmm12,%xmm5
addpd  %xmm11,%xmm1
addpd  %xmm10,%xmm0
movapd %xmm5,0x40(%rsp)
movsd  %xmm8,0x50(%rsp)
movsd  %xmm4,0x60(%rsp)
movsd  %xmm9,0x68(%rsp)
movapd %xmm0,0x20(%rsp)
movsd  %xmm3,0x30(%rsp)
movapd %xmm1,(%rsp)
movsd  %xmm13,0x10(%rsp)
unpckhpd %xmm5,%xmm5
jmp    12da <ctm_fitting+0x1aa>
movsd  0x48(%rsp),%xmm5
movsd  0x50(%rsp),%xmm8
movsd  0x68(%rsp),%xmm9
movsd  %xmm5,0x58(%rsp)
movsd  %xmm8,0x70(%rsp)
movsd  %xmm9,0x78(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
movsd  %xmm0,0x80(%rsp)
lea    0xcfe(%rip),%rdi
lea    0x40(%rsp),%rsi
mov    $0x3,%edx
mov    $0x3,%ecx
call   1050 <print_matrix@plt>
lea    0xceb(%rip),%rdi
lea    0x20(%rsp),%rsi
mov    $0x3,%edx
mov    $0x1,%ecx
call   1050 <print_matrix@plt>
lea    0xcd8(%rip),%rdi
mov    %rsp,%rsi
mov    $0x3,%edx
mov    $0x1,%ecx
call   1050 <print_matrix@plt>
movaps 0x40(%rsp),%xmm0
movaps %xmm0,0x130(%rsp)
movsd  0x50(%rsp),%xmm1
movsd  %xmm1,0x140(%rsp)
movsd  0x20(%rsp),%xmm2
movsd  0x28(%rsp),%xmm3
movsd  %xmm2,0x148(%rsp)
movups 0x58(%rsp),%xmm2
movaps %xmm2,0x150(%rsp)
movsd  0x68(%rsp),%xmm4
movsd  %xmm4,0x160(%rsp)
movsd  %xmm3,0x168(%rsp)
movaps 0x70(%rsp),%xmm3
movaps %xmm3,0x170(%rsp)
movsd  0x80(%rsp),%xmm5
movsd  %xmm5,0x180(%rsp)
movsd  0x30(%rsp),%xmm6
movsd  %xmm6,0x188(%rsp)
movaps %xmm0,0xd0(%rsp)
movsd  %xmm1,0xe0(%rsp)
movsd  (%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
movsd  %xmm0,0xe8(%rsp)
movaps %xmm2,0xf0(%rsp)
movsd  %xmm4,0x100(%rsp)
movsd  %xmm1,0x108(%rsp)
movaps %xmm3,0x110(%rsp)
movsd  %xmm5,0x120(%rsp)
movsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x128(%rsp)
lea    0xbd0(%rip),%rdi
lea    0x130(%rsp),%r15
mov    %r15,%rsi
mov    $0x3,%edx
mov    $0x4,%ecx
call   1050 <print_matrix@plt>
lea    0xbb7(%rip),%rdi
lea    0xd0(%rsp),%rbp
mov    %rbp,%rsi
mov    $0x3,%edx
mov    $0x4,%ecx
call   1050 <print_matrix@plt>
lea    0xb0(%rsp),%rbx
mov    %r15,%rdi
mov    %rbx,%rsi
mov    $0x3,%edx
call   1040 <gauss1@plt>
lea    0x90(%rsp),%r15
mov    %rbp,%rdi
mov    %r15,%rsi
mov    $0x3,%edx
call   1040 <gauss1@plt>
lea    0xb6e(%rip),%rdi
mov    %rbx,%rsi
mov    $0x3,%edx
mov    $0x1,%ecx
call   1050 <print_matrix@plt>
lea    0xb59(%rip),%rdi
mov    %r15,%rsi
mov    $0x3,%edx
mov    $0x1,%ecx
call   1050 <print_matrix@plt>
movaps 0xb0(%rsp),%xmm0
movups %xmm0,(%r14)
mov    0xc0(%rsp),%rax
mov    %rax,0x10(%r14)
movaps 0x90(%rsp),%xmm0
movups %xmm0,0x18(%r14)
mov    0xa0(%rsp),%rax
mov    %rax,0x28(%r14)
xorps  %xmm0,%xmm0
movups %xmm0,0x30(%r14)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x40(%r14)
add    $0x198,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c"XY\00"
@.str.1 = [4 x i8] c"ata\00"
@.str.2 = [4 x i8] c"atx\00"
@.str.3 = [4 x i8] c"aty\00"
@.str.4 = [8 x i8] c"ata\\atx\00"
@.str.5 = [8 x i8] c"ata\\aty\00"
@.str.6 = [4 x i8] c"abc\00"
@.str.7 = [4 x i8] c"def\00"
define void @ctm_fitting(double* %0, i32 %1, double* %2) {
%4 = alloca double*
%5 = alloca i32
%6 = alloca double*
%7 = alloca i32
%8 = alloca [3 x double]
%9 = alloca [3 x double]
%10 = alloca [9 x double]
%11 = alloca [3 x double]
%12 = alloca [3 x double]
%13 = alloca double*
%14 = alloca [12 x double]
%15 = alloca [12 x double]
%16 = alloca double*
%17 = alloca double*
%18 = alloca double*
%19 = alloca double*
%20 = alloca double*
%21 = alloca double*
store double* %0, double** %4
store i32 %1, i32* %5
store double* %2, double** %6
%22 = getelementptr inbounds [9 x double], [9 x double]* %10, i64 0, i64 0
%23 = call i32 @memset(double* %22, i32 0, i32 72)
%24 = getelementptr inbounds [3 x double], [3 x double]* %11, i64 0, i64 0
%25 = call i32 @memset(double* %24, i32 0, i32 24)
%26 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 0
%27 = call i32 @memset(double* %26, i32 0, i32 24)
%28 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 0
%29 = call i32 @memset(double* %28, i32 0, i32 24)
%30 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 0
%31 = call i32 @memset(double* %30, i32 0, i32 24)
%32 = load double*, double** %4
%33 = load i32, i32* %5
%34 = call i32 @print_matrix(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), double* %32, i32 %33, i32 4)
store i32 0, i32* %7
br label %35
35: ; preds = %132, %3
%36 = load i32, i32* %7
%37 = load i32, i32* %5
%38 = icmp slt i32 %36, %37
br i1 %38, label %39, label %135
39: ; preds = %35
%40 = load double*, double** %4
%41 = load i32, i32* %7
%42 = mul nsw i32 4, %41
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds double, double* %40, i64 %43
store double* %44, double** %13
%45 = load double*, double** %13
%46 = getelementptr inbounds double, double* %45, i64 0
%47 = load double, double* %46
%48 = load double*, double** %13
%49 = getelementptr inbounds double, double* %48, i64 0
%50 = load double, double* %49
%51 = getelementptr inbounds [9 x double], [9 x double]* %10, i64 0, i64 0
%52 = load double, double* %51
%53 = call double @llvm.fmuladd.f64(double %47, double %50, double %52)
store double %53, double* %51
%54 = load double*, double** %13
%55 = getelementptr inbounds double, double* %54, i64 0
%56 = load double, double* %55
%57 = load double*, double** %13
%58 = getelementptr inbounds double, double* %57, i64 1
%59 = load double, double* %58
%60 = getelementptr inbounds [9 x double], [9 x double]* %10, i64 0, i64 1
%61 = load double, double* %60
%62 = call double @llvm.fmuladd.f64(double %56, double %59, double %61)
store double %62, double* %60
%63 = load double*, double** %13
%64 = getelementptr inbounds double, double* %63, i64 0
%65 = load double, double* %64
%66 = getelementptr inbounds [9 x double], [9 x double]* %10, i64 0, i64 2
%67 = load double, double* %66
%68 = fadd double %67, %65
store double %68, double* %66
%69 = load double*, double** %13
%70 = getelementptr inbounds double, double* %69, i64 1
%71 = load double, double* %70
%72 = load double*, double** %13
%73 = getelementptr inbounds double, double* %72, i64 1
%74 = load double, double* %73
%75 = getelementptr inbounds [9 x double], [9 x double]* %10, i64 0, i64 4
%76 = load double, double* %75
%77 = call double @llvm.fmuladd.f64(double %71, double %74, double %76)
store double %77, double* %75
%78 = load double*, double** %13
%79 = getelementptr inbounds double, double* %78, i64 1
%80 = load double, double* %79
%81 = getelementptr inbounds [9 x double], [9 x double]* %10, i64 0, i64 5
%82 = load double, double* %81
%83 = fadd double %82, %80
store double %83, double* %81
%84 = load double*, double** %13
%85 = getelementptr inbounds double, double* %84, i64 0
%86 = load double, double* %85
%87 = load double*, double** %13
%88 = getelementptr inbounds double, double* %87, i64 2
%89 = load double, double* %88
%90 = getelementptr inbounds [3 x double], [3 x double]* %11, i64 0, i64 0
%91 = load double, double* %90
%92 = call double @llvm.fmuladd.f64(double %86, double %89, double %91)
store double %92, double* %90
%93 = load double*, double** %13
%94 = getelementptr inbounds double, double* %93, i64 1
%95 = load double, double* %94
%96 = load double*, double** %13
%97 = getelementptr inbounds double, double* %96, i64 2
%98 = load double, double* %97
%99 = getelementptr inbounds [3 x double], [3 x double]* %11, i64 0, i64 1
%100 = load double, double* %99
%101 = call double @llvm.fmuladd.f64(double %95, double %98, double %100)
store double %101, double* %99
%102 = load double*, double** %13
%103 = getelementptr inbounds double, double* %102, i64 2
%104 = load double, double* %103
%105 = getelementptr inbounds [3 x double], [3 x double]* %11, i64 0, i64 2
%106 = load double, double* %105
%107 = fadd double %106, %104
store double %107, double* %105
%108 = load double*, double** %13
%109 = getelementptr inbounds double, double* %108, i64 0
%110 = load double, double* %109
%111 = load double*, double** %13
%112 = getelementptr inbounds double, double* %111, i64 3
%113 = load double, double* %112
%114 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 0
%115 = load double, double* %114
%116 = call double @llvm.fmuladd.f64(double %110, double %113, double %115)
store double %116, double* %114
%117 = load double*, double** %13
%118 = getelementptr inbounds double, double* %117, i64 1
%119 = load double, double* %118
%120 = load double*, double** %13
%121 = getelementptr inbounds double, double* %120, i64 3
%122 = load double, double* %121
%123 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 1
%124 = load double, double* %123
%125 = call double @llvm.fmuladd.f64(double %119, double %122, double %124)
store double %125, double* %123
%126 = load double*, double** %13
%127 = getelementptr inbounds double, double* %126, i64 3
%128 = load double, double* %127
%129 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 2
%130 = load double, double* %129
%131 = fadd double %130, %128
store double %131, double* %129
br label %132
132: ; preds = %39
%133 = load i32, i32* %7
%134 = add nsw i32 %133, 1
store i32 %134, i32* %7
br label %35
135: ; preds = %35
%136 = getelementptr inbounds [9 x double], [9 x double]* %10, i64 0, i64 1
%137 = load double, double* %136
%138 = getelementptr inbounds [9 x double], [9 x double]* %10, i64 0, i64 3
store double %137, double* %138
%139 = getelementptr inbounds [9 x double], [9 x double]* %10, i64 0, i64 2
%140 = load double, double* %139
%141 = getelementptr inbounds [9 x double], [9 x double]* %10, i64 0, i64 6
store double %140, double* %141
%142 = getelementptr inbounds [9 x double], [9 x double]* %10, i64 0, i64 5
%143 = load double, double* %142
%144 = getelementptr inbounds [9 x double], [9 x double]* %10, i64 0, i64 7
store double %143, double* %144
%145 = load i32, i32* %5
%146 = sitofp i32 %145 to double
%147 = getelementptr inbounds [9 x double], [9 x double]* %10, i64 0, i64 8
store double %146, double* %147
%148 = getelementptr inbounds [9 x double], [9 x double]* %10, i64 0, i64 0
%149 = call i32 @print_matrix(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %148, i32 3, i32 3)
%150 = getelementptr inbounds [3 x double], [3 x double]* %11, i64 0, i64 0
%151 = call i32 @print_matrix(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double* %150, i32 3, i32 1)
%152 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 0
%153 = call i32 @print_matrix(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), double* %152, i32 3, i32 1)
store i32 0, i32* %7
br label %154
154: ; preds = %192, %135
%155 = load i32, i32* %7
%156 = icmp slt i32 %155, 3
br i1 %156, label %157, label %195
157: ; preds = %154
%158 = getelementptr inbounds [12 x double], [12 x double]* %14, i64 0, i64 0
%159 = load i32, i32* %7
%160 = mul nsw i32 %159, 4
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds double, double* %158, i64 %161
store double* %162, double** %16
%163 = getelementptr inbounds [9 x double], [9 x double]* %10, i64 0, i64 0
%164 = load i32, i32* %7
%165 = mul nsw i32 %164, 3
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds double, double* %163, i64 %166
store double* %167, double** %17
%168 = getelementptr inbounds [3 x double], [3 x double]* %11, i64 0, i64 0
%169 = load i32, i32* %7
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds double, double* %168, i64 %170
store double* %171, double** %18
%172 = load double*, double** %17
%173 = getelementptr inbounds double, double* %172, i64 0
%174 = load double, double* %173
%175 = load double*, double** %16
%176 = getelementptr inbounds double, double* %175, i64 0
store double %174, double* %176
%177 = load double*, double** %17
%178 = getelementptr inbounds double, double* %177, i64 1
%179 = load double, double* %178
%180 = load double*, double** %16
%181 = getelementptr inbounds double, double* %180, i64 1
store double %179, double* %181
%182 = load double*, double** %17
%183 = getelementptr inbounds double, double* %182, i64 2
%184 = load double, double* %183
%185 = load double*, double** %16
%186 = getelementptr inbounds double, double* %185, i64 2
store double %184, double* %186
%187 = load double*, double** %18
%188 = getelementptr inbounds double, double* %187, i64 0
%189 = load double, double* %188
%190 = load double*, double** %16
%191 = getelementptr inbounds double, double* %190, i64 3
store double %189, double* %191
br label %192
192: ; preds = %157
%193 = load i32, i32* %7
%194 = add nsw i32 %193, 1
store i32 %194, i32* %7
br label %154
195: ; preds = %154
store i32 0, i32* %7
br label %196
196: ; preds = %234, %195
%197 = load i32, i32* %7
%198 = icmp slt i32 %197, 3
br i1 %198, label %199, label %237
199: ; preds = %196
%200 = getelementptr inbounds [12 x double], [12 x double]* %15, i64 0, i64 0
%201 = load i32, i32* %7
%202 = mul nsw i32 %201, 4
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds double, double* %200, i64 %203
store double* %204, double** %19
%205 = getelementptr inbounds [9 x double], [9 x double]* %10, i64 0, i64 0
%206 = load i32, i32* %7
%207 = mul nsw i32 %206, 3
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds double, double* %205, i64 %208
store double* %209, double** %20
%210 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 0
%211 = load i32, i32* %7
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds double, double* %210, i64 %212
store double* %213, double** %21
%214 = load double*, double** %20
%215 = getelementptr inbounds double, double* %214, i64 0
%216 = load double, double* %215
%217 = load double*, double** %19
%218 = getelementptr inbounds double, double* %217, i64 0
store double %216, double* %218
%219 = load double*, double** %20
%220 = getelementptr inbounds double, double* %219, i64 1
%221 = load double, double* %220
%222 = load double*, double** %19
%223 = getelementptr inbounds double, double* %222, i64 1
store double %221, double* %223
%224 = load double*, double** %20
%225 = getelementptr inbounds double, double* %224, i64 2
%226 = load double, double* %225
%227 = load double*, double** %19
%228 = getelementptr inbounds double, double* %227, i64 2
store double %226, double* %228
%229 = load double*, double** %21
%230 = getelementptr inbounds double, double* %229, i64 0
%231 = load double, double* %230
%232 = load double*, double** %19
%233 = getelementptr inbounds double, double* %232, i64 3
store double %231, double* %233
br label %234
234: ; preds = %199
%235 = load i32, i32* %7
%236 = add nsw i32 %235, 1
store i32 %236, i32* %7
br label %196
237: ; preds = %196
%238 = getelementptr inbounds [12 x double], [12 x double]* %14, i64 0, i64 0
%239 = call i32 @print_matrix(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0), double* %238, i32 3, i32 4)
%240 = getelementptr inbounds [12 x double], [12 x double]* %15, i64 0, i64 0
%241 = call i32 @print_matrix(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.5, i64 0, i64 0), double* %240, i32 3, i32 4)
%242 = getelementptr inbounds [12 x double], [12 x double]* %14, i64 0, i64 0
%243 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 0
%244 = call i32 @gauss1(double* %242, double* %243, i32 3)
%245 = getelementptr inbounds [12 x double], [12 x double]* %15, i64 0, i64 0
%246 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 0
%247 = call i32 @gauss1(double* %245, double* %246, i32 3)
%248 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 0
%249 = call i32 @print_matrix(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %248, i32 3, i32 1)
%250 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 0
%251 = call i32 @print_matrix(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), double* %250, i32 3, i32 1)
store i32 0, i32* %7
br label %252
252: ; preds = %274, %237
%253 = load i32, i32* %7
%254 = icmp slt i32 %253, 3
br i1 %254, label %255, label %277
255: ; preds = %252
%256 = load i32, i32* %7
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 %257
%259 = load double, double* %258
%260 = load double*, double** %6
%261 = load i32, i32* %7
%262 = add nsw i32 0, %261
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds double, double* %260, i64 %263
store double %259, double* %264
%265 = load i32, i32* %7
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 %266
%268 = load double, double* %267
%269 = load double*, double** %6
%270 = load i32, i32* %7
%271 = add nsw i32 3, %270
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds double, double* %269, i64 %272
store double %268, double* %273
br label %274
274: ; preds = %255
%275 = load i32, i32* %7
%276 = add nsw i32 %275, 1
store i32 %276, i32* %7
br label %252
277: ; preds = %252
%278 = load double*, double** %6
%279 = getelementptr inbounds double, double* %278, i64 6
store double 0.000000e+00, double* %279
%280 = load double*, double** %6
%281 = getelementptr inbounds double, double* %280, i64 7
store double 0.000000e+00, double* %281
%282 = load double*, double** %6
%283 = getelementptr inbounds double, double* %282, i64 8
store double 1.000000e+00, double* %283
ret void
}

LLVM IR (-O2):
@.str = [3 x i8] c"XY\00"
@.str.1 = [4 x i8] c"ata\00"
@.str.2 = [4 x i8] c"atx\00"
@.str.3 = [4 x i8] c"aty\00"
@.str.4 = [8 x i8] c"ata\\atx\00"
@.str.5 = [8 x i8] c"ata\\aty\00"
@.str.6 = [4 x i8] c"abc\00"
@.str.7 = [4 x i8] c"def\00"
define void @ctm_fitting(double* %0, i32 %1, double* nocapture writeonly %2) {
%4 = alloca [3 x double]
%5 = bitcast [3 x double]* %4 to i8*
%6 = alloca [3 x double]
%7 = bitcast [3 x double]* %6 to i8*
%8 = alloca [9 x double]
%9 = alloca [3 x double]
%10 = alloca [3 x double]
%11 = alloca [12 x double]
%12 = alloca [12 x double]
%13 = bitcast [9 x double]* %8 to i8*
%14 = bitcast [3 x double]* %9 to i8*
%15 = bitcast [3 x double]* %10 to i8*
%16 = getelementptr inbounds [9 x double], [9 x double]* %8, i64 0, i64 0
%17 = call i32 @memset(double* %16, i32 0, i32 72)
%18 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 0
%19 = call i32 @memset(double* %18, i32 0, i32 24)
%20 = getelementptr inbounds [3 x double], [3 x double]* %10, i64 0, i64 0
%21 = call i32 @memset(double* %20, i32 0, i32 24)
%22 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%23 = call i32 @memset(double* %22, i32 0, i32 24)
%24 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 0
%25 = call i32 @memset(double* %24, i32 0, i32 24)
%26 = call i32 @print_matrix(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), double* %0, i32 %1, i32 4)
%27 = icmp sgt i32 %1, 0
br i1 %27, label %35, label %28
28: ; preds = %3
%29 = getelementptr inbounds [9 x double], [9 x double]* %8, i64 0, i64 1
%30 = load double, double* %29
%31 = getelementptr inbounds [9 x double], [9 x double]* %8, i64 0, i64 2
%32 = load double, double* %31
%33 = getelementptr inbounds [9 x double], [9 x double]* %8, i64 0, i64 5
%34 = load double, double* %33
br label %96
35: ; preds = %3
%36 = getelementptr inbounds [9 x double], [9 x double]* %8, i64 0, i64 2
%37 = getelementptr inbounds [9 x double], [9 x double]* %8, i64 0, i64 4
%38 = getelementptr inbounds [9 x double], [9 x double]* %8, i64 0, i64 5
%39 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 2
%40 = getelementptr inbounds [3 x double], [3 x double]* %10, i64 0, i64 2
%41 = bitcast [9 x double]* %8 to <2 x double>*
%42 = load <2 x double>, <2 x double>* %41
%43 = load double, double* %36
%44 = load double, double* %37
%45 = load double, double* %38
%46 = bitcast [3 x double]* %9 to <2 x double>*
%47 = load <2 x double>, <2 x double>* %46
%48 = load double, double* %39
%49 = bitcast [3 x double]* %10 to <2 x double>*
%50 = load <2 x double>, <2 x double>* %49
%51 = load double, double* %40
%52 = zext i32 %1 to i64
br label %53
53: ; preds = %35, %53
%54 = phi i64 [ 0, %35 ], [ %86, %53 ]
%55 = phi double [ %51, %35 ], [ %85, %53 ]
%56 = phi double [ %48, %35 ], [ %79, %53 ]
%57 = phi double [ %45, %35 ], [ %73, %53 ]
%58 = phi double [ %44, %35 ], [ %72, %53 ]
%59 = phi double [ %43, %35 ], [ %70, %53 ]
%60 = phi <2 x double> [ %42, %35 ], [ %69, %53 ]
%61 = phi <2 x double> [ %47, %35 ], [ %78, %53 ]
%62 = phi <2 x double> [ %50, %35 ], [ %84, %53 ]
%63 = shl nsw i64 %54, 2
%64 = getelementptr inbounds double, double* %0, i64 %63
%65 = bitcast double* %64 to <2 x double>*
%66 = load <2 x double>, <2 x double>* %65
%67 = extractelement <2 x double> %66, i64 0
%68 = shufflevector <2 x double> %66, <2 x double> undef, <2 x i32> zeroinitializer
%69 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %68, <2 x double> %66, <2 x double> %60)
%70 = fadd double %67, %59
%71 = extractelement <2 x double> %66, i64 1
%72 = call double @llvm.fmuladd.f64(double %71, double %71, double %58)
%73 = fadd double %71, %57
%74 = getelementptr inbounds double, double* %64, i64 2
%75 = load double, double* %74
%76 = insertelement <2 x double> poison, double %75, i64 0
%77 = shufflevector <2 x double> %76, <2 x double> poison, <2 x i32> zeroinitializer
%78 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %66, <2 x double> %77, <2 x double> %61)
%79 = fadd double %75, %56
%80 = getelementptr inbounds double, double* %64, i64 3
%81 = load double, double* %80
%82 = insertelement <2 x double> poison, double %81, i64 0
%83 = shufflevector <2 x double> %82, <2 x double> poison, <2 x i32> zeroinitializer
%84 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %66, <2 x double> %83, <2 x double> %62)
%85 = fadd double %81, %55
%86 = add nuw nsw i64 %54, 1
%87 = icmp eq i64 %86, %52
br i1 %87, label %88, label %53
88: ; preds = %53
%89 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %68, <2 x double> %66, <2 x double> %60)
%90 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %66, <2 x double> %83, <2 x double> %62)
%91 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %66, <2 x double> %77, <2 x double> %61)
%92 = bitcast [9 x double]* %8 to <2 x double>*
store <2 x double> %89, <2 x double>* %92
store double %70, double* %36
store double %72, double* %37
store double %73, double* %38
%93 = bitcast [3 x double]* %9 to <2 x double>*
store <2 x double> %91, <2 x double>* %93
store double %79, double* %39
%94 = bitcast [3 x double]* %10 to <2 x double>*
store <2 x double> %90, <2 x double>* %94
store double %85, double* %40
%95 = extractelement <2 x double> %89, i64 1
br label %96
96: ; preds = %28, %88
%97 = phi double [ %34, %28 ], [ %73, %88 ]
%98 = phi double [ %32, %28 ], [ %70, %88 ]
%99 = phi double [ %30, %28 ], [ %95, %88 ]
%100 = bitcast double* %2 to i8*
%101 = getelementptr inbounds [9 x double], [9 x double]* %8, i64 0, i64 3
store double %99, double* %101
%102 = getelementptr inbounds [9 x double], [9 x double]* %8, i64 0, i64 6
store double %98, double* %102
%103 = getelementptr inbounds [9 x double], [9 x double]* %8, i64 0, i64 7
store double %97, double* %103
%104 = sitofp i32 %1 to double
%105 = getelementptr inbounds [9 x double], [9 x double]* %8, i64 0, i64 8
store double %104, double* %105
%106 = call i32 @print_matrix(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %16, i32 3, i32 3)
%107 = call i32 @print_matrix(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double* %18, i32 3, i32 1)
%108 = call i32 @print_matrix(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), double* %20, i32 3, i32 1)
%109 = bitcast [12 x double]* %11 to i8*
%110 = bitcast [12 x double]* %12 to i8*
%111 = getelementptr inbounds [12 x double], [12 x double]* %11, i64 0, i64 0
%112 = bitcast [9 x double]* %8 to <2 x double>*
%113 = load <2 x double>, <2 x double>* %112
%114 = bitcast [12 x double]* %11 to <2 x double>*
store <2 x double> %113, <2 x double>* %114
%115 = getelementptr inbounds [9 x double], [9 x double]* %8, i64 0, i64 2
%116 = load double, double* %115
%117 = getelementptr inbounds [12 x double], [12 x double]* %11, i64 0, i64 2
store double %116, double* %117
%118 = load double, double* %18
%119 = getelementptr inbounds [12 x double], [12 x double]* %11, i64 0, i64 3
store double %118, double* %119
%120 = getelementptr inbounds [12 x double], [12 x double]* %11, i64 0, i64 4
%121 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 1
%122 = bitcast double* %101 to <2 x double>*
%123 = load <2 x double>, <2 x double>* %122
%124 = bitcast double* %120 to <2 x double>*
store <2 x double> %123, <2 x double>* %124
%125 = getelementptr inbounds [9 x double], [9 x double]* %8, i64 0, i64 5
%126 = load double, double* %125
%127 = getelementptr inbounds [12 x double], [12 x double]* %11, i64 0, i64 6
store double %126, double* %127
%128 = load double, double* %121
%129 = getelementptr inbounds [12 x double], [12 x double]* %11, i64 0, i64 7
store double %128, double* %129
%130 = getelementptr inbounds [12 x double], [12 x double]* %11, i64 0, i64 8
%131 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 2
%132 = bitcast double* %102 to <2 x double>*
%133 = load <2 x double>, <2 x double>* %132
%134 = bitcast double* %130 to <2 x double>*
store <2 x double> %133, <2 x double>* %134
%135 = getelementptr inbounds [9 x double], [9 x double]* %8, i64 0, i64 8
%136 = load double, double* %135
%137 = getelementptr inbounds [12 x double], [12 x double]* %11, i64 0, i64 10
store double %136, double* %137
%138 = load double, double* %131
%139 = getelementptr inbounds [12 x double], [12 x double]* %11, i64 0, i64 11
store double %138, double* %139
%140 = getelementptr inbounds [12 x double], [12 x double]* %12, i64 0, i64 0
%141 = bitcast [12 x double]* %12 to <2 x double>*
store <2 x double> %113, <2 x double>* %141
%142 = getelementptr inbounds [12 x double], [12 x double]* %12, i64 0, i64 2
store double %116, double* %142
%143 = load double, double* %20
%144 = getelementptr inbounds [12 x double], [12 x double]* %12, i64 0, i64 3
store double %143, double* %144
%145 = getelementptr inbounds [12 x double], [12 x double]* %12, i64 0, i64 4
%146 = getelementptr inbounds [3 x double], [3 x double]* %10, i64 0, i64 1
%147 = bitcast double* %145 to <2 x double>*
store <2 x double> %123, <2 x double>* %147
%148 = getelementptr inbounds [12 x double], [12 x double]* %12, i64 0, i64 6
store double %126, double* %148
%149 = load double, double* %146
%150 = getelementptr inbounds [12 x double], [12 x double]* %12, i64 0, i64 7
store double %149, double* %150
%151 = getelementptr inbounds [12 x double], [12 x double]* %12, i64 0, i64 8
%152 = getelementptr inbounds [3 x double], [3 x double]* %10, i64 0, i64 2
%153 = bitcast double* %151 to <2 x double>*
store <2 x double> %133, <2 x double>* %153
%154 = getelementptr inbounds [12 x double], [12 x double]* %12, i64 0, i64 10
store double %136, double* %154
%155 = load double, double* %152
%156 = getelementptr inbounds [12 x double], [12 x double]* %12, i64 0, i64 11
store double %155, double* %156
%157 = call i32 @print_matrix(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0), double* %111, i32 3, i32 4)
%158 = call i32 @print_matrix(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.5, i64 0, i64 0), double* %140, i32 3, i32 4)
%159 = call i32 @gauss1(double* %111, double* %24, i32 3)
%160 = call i32 @gauss1(double* %140, double* %22, i32 3)
%161 = call i32 @print_matrix(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %24, i32 3, i32 1)
%162 = call i32 @print_matrix(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), double* %22, i32 3, i32 1)
%163 = getelementptr double, double* %2, i64 3
%164 = bitcast double* %163 to i8*
%165 = getelementptr inbounds double, double* %2, i64 6
%166 = getelementptr inbounds double, double* %2, i64 8
%167 = bitcast double* %165 to i8*
store double 1.000000e+00, double* %166
ret void
}