#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*/ fputs(char *, int /*<<< orphan*/);
int /*<<< orphan*/ free(float *);
float *malloc(long);
int /*<<< orphan*/ printf(char *, float);
int /*<<< orphan*/ printmatf(char *, float *, int, int);
int /*<<< orphan*/ puts(char *);
float *realloc(float *, long);
int /*<<< orphan*/ scanf(char *, ...);
int /*<<< orphan*/ stdout;
float *transpose(float *, int, int);
int /*<<< orphan*/ ut(float *, int, int);
int main() {
  int n;
  puts("Please input the size of the square matrix:");
  fputs("n = ", stdout);
  scanf("%d", &n);
  long i, j, k, len = n * n * sizeof(float);
  float sum = 0.0, *a = malloc(len);
  puts("Now please input the matrix:");
  for (i = 0; i < n * n; ++i) {
    scanf("%f", a + i);
    sum += a[i];
  }
  printf("The sum of all the matrix elements: %.2f\n", sum);
  float *b = transpose(a, n, n);
  puts("The transpose of the matrix:");
  printmatf("%8.3f", b, n, n);
  free(a);
  b = realloc(b, len * 2);
  for (i = 0; i < n; ++i)
    for (j = 0; j < n; ++j)
      b[n * n + i * n + j] = i == j;
  a = transpose(b, n * 2, n);
  ut(a, n, n * 2);
  free(b);
  float det = 1.0;
  for (i = 0; i < n; ++i)
    det *= a[i * n * 2 + i];
  printf("The determinant of the matrix: %.2f\n", det);
  if (!det) {
    puts("The given matrix is not invertible.");
    free(a);
    return 0;
  }
  for (i = n - 1; i >= 0; --i) {
    float d = a[i * n * 2 + i];
    for (j = n; j < n * 2; ++j)
      a[i * n * 2 + j] /= d;
    for (k = i - 1; k >= 0; --k) {
      float c = a[k * n * 2 + i];
      for (j = n; j < n * 2; ++j)
        a[k * n * 2 + j] -= a[i * n * 2 + j] * c;
    }
  }
  b = transpose(a, n, n * 2);
  a = transpose(b + n * n, n, n);
  puts("The inverse of the matrix:");
  printmatf("%8.3f", a, n, n);
  free(a);
  free(b);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xe4e(%rip),%rdi
call   1040 <puts@plt>
mov    0x2e1e(%rip),%rax
mov    (%rax),%esi
lea    0xe65(%rip),%rdi
call   1060 <fputs@plt>
lea    0xe5e(%rip),%rdi
lea    -0x8(%rbp),%rsi
mov    $0x0,%al
call   10b0 <scanf@plt>
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %rax,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x28(%rbp),%rdi
call   1090 <malloc@plt>
mov    %rax,-0x38(%rbp)
lea    0xe29(%rip),%rdi
call   1040 <puts@plt>
movq   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x8(%rbp),%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jge    1278 <main+0xd8>
mov    -0x38(%rbp),%rsi
mov    -0x10(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe0c(%rip),%rdi
mov    $0x0,%al
call   10b0 <scanf@plt>
mov    -0x38(%rbp),%rax
mov    -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    121c <main+0x7c>
movss  -0x2c(%rbp),%xmm0
lea    0xdd4(%rip),%rdi
call   1050 <printf@plt>
mov    -0x38(%rbp),%rdi
mov    -0x8(%rbp),%esi
mov    -0x8(%rbp),%edx
call   1080 <transpose@plt>
mov    %rax,-0x40(%rbp)
lea    0xddf(%rip),%rdi
call   1040 <puts@plt>
mov    -0x40(%rbp),%rsi
mov    -0x8(%rbp),%edx
mov    -0x8(%rbp),%ecx
lea    0xde6(%rip),%rdi
call   10c0 <printmatf@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
mov    -0x28(%rbp),%rsi
shl    $0x1,%rsi
call   10a0 <realloc@plt>
mov    %rax,-0x40(%rbp)
movq   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    136f <main+0x1cf>
movq   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    1359 <main+0x1b9>
mov    -0x10(%rbp),%rax
cmp    -0x18(%rbp),%rax
sete   %al
and    $0x1,%al
movzbl %al,%eax
cvtsi2ss %eax,%xmm0
mov    -0x40(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x8(%rbp),%ecx
movslq %ecx,%rcx
mov    -0x10(%rbp),%rdx
movslq -0x8(%rbp),%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
add    -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    12fd <main+0x15d>
jmp    135e <main+0x1be>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    12e4 <main+0x144>
mov    -0x40(%rbp),%rdi
mov    -0x8(%rbp),%esi
shl    $0x1,%esi
mov    -0x8(%rbp),%edx
call   1080 <transpose@plt>
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x8(%rbp),%esi
mov    -0x8(%rbp),%edx
shl    $0x1,%edx
call   1070 <ut@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
movss  0xc58(%rip),%xmm0
movss  %xmm0,-0x44(%rbp)
movq   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    13fe <main+0x25e>
mov    -0x38(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x8(%rbp),%rdx
imul   %rdx,%rcx
shl    $0x1,%rcx
add    -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    13b5 <main+0x215>
movss  -0x44(%rbp),%xmm0
lea    0xc9b(%rip),%rdi
call   1050 <printf@plt>
movss  -0x44(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1447 <main+0x2a7>
jp     1447 <main+0x2a7>
lea    0xc9d(%rip),%rdi
call   1040 <puts@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
jmp    163c <main+0x49c>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %rax,-0x10(%rbp)
cmpq   $0x0,-0x10(%rbp)
jl     15c8 <main+0x428>
mov    -0x38(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x8(%rbp),%rdx
imul   %rdx,%rcx
shl    $0x1,%rcx
add    -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movslq -0x8(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jge    14da <main+0x33a>
movss  -0x48(%rbp),%xmm1
mov    -0x38(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x8(%rbp),%rdx
imul   %rdx,%rcx
shl    $0x1,%rcx
add    -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1488 <main+0x2e8>
mov    -0x10(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
jl     15b2 <main+0x412>
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x8(%rbp),%rdx
imul   %rdx,%rcx
shl    $0x1,%rcx
add    -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
movslq -0x8(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jge    159c <main+0x3fc>
mov    -0x38(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x8(%rbp),%rdx
imul   %rdx,%rcx
shl    $0x1,%rcx
add    -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x4c(%rbp),%xmm2
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x8(%rbp),%rdx
imul   %rdx,%rcx
shl    $0x1,%rcx
add    -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    151b <main+0x37b>
jmp    15a1 <main+0x401>
mov    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
jmp    14e6 <main+0x346>
jmp    15b7 <main+0x417>
mov    -0x10(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x10(%rbp)
jmp    1453 <main+0x2b3>
mov    -0x38(%rbp),%rdi
mov    -0x8(%rbp),%esi
mov    -0x8(%rbp),%edx
shl    $0x1,%edx
call   1080 <transpose@plt>
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rdi
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x8(%rbp),%esi
mov    -0x8(%rbp),%edx
call   1080 <transpose@plt>
mov    %rax,-0x38(%rbp)
lea    0xae6(%rip),%rdi
call   1040 <puts@plt>
mov    -0x38(%rbp),%rsi
mov    -0x8(%rbp),%edx
mov    -0x8(%rbp),%ecx
lea    0xa81(%rip),%rdi
call   10c0 <printmatf@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
lea    0xe4c(%rip),%rdi
call   1040 <puts@plt>
mov    0x2e1c(%rip),%rax
mov    (%rax),%esi
lea    0xe63(%rip),%rdi
call   1060 <fputs@plt>
lea    0xe5c(%rip),%rdi
lea    0x4(%rsp),%rsi
xor    %eax,%eax
call   10b0 <scanf@plt>
mov    0x4(%rsp),%r14d
imul   %r14d,%r14d
lea    0x0(,%r14,4),%rdi
call   1090 <malloc@plt>
mov    %rax,%r12
lea    0xe33(%rip),%rdi
call   1040 <puts@plt>
mov    0x4(%rsp),%eax
imul   %eax,%eax
xorps  %xmm0,%xmm0
test   %eax,%eax
je     1264 <main+0xc4>
lea    0xe36(%rip),%r15
xor    %ebp,%ebp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  %xmm0,0x8(%rsp)
lea    (%r12,%rbp,1),%rsi
mov    %r15,%rdi
xor    %eax,%eax
call   10b0 <scanf@plt>
movss  0x8(%rsp),%xmm0
addss  (%r12,%rbx,4),%xmm0
add    $0x1,%rbx
mov    0x4(%rsp),%eax
imul   %eax,%eax
add    $0x4,%rbp
cmp    %rax,%rbx
jb     1230 <main+0x90>
lea    0xded(%rip),%rdi
call   1050 <printf@plt>
mov    0x4(%rsp),%edx
mov    %r12,%rdi
mov    %edx,%esi
call   1080 <transpose@plt>
mov    %rax,%r15
lea    0xdfa(%rip),%rdi
call   1040 <puts@plt>
mov    0x4(%rsp),%ecx
lea    0xe07(%rip),%rdi
mov    %r15,%rsi
mov    %ecx,%edx
call   10c0 <printmatf@plt>
mov    %r12,%rdi
call   1030 <free@plt>
shl    $0x3,%r14
mov    %r15,%rdi
mov    %r14,%rsi
call   10a0 <realloc@plt>
mov    %rax,%r14
movslq 0x4(%rsp),%rdx
test   %rdx,%rdx
jle    13bb <main+0x21b>
mov    %edx,%r10d
imul   %r10d,%r10d
lea    -0x1(%rdx),%r8
mov    %edx,%esi
and    $0x3,%esi
mov    %rdx,%r11
and    $0xfffffffffffffffc,%r11
lea    (%r14,%r10,4),%rbp
add    $0xc,%rbp
lea    0x0(,%rdx,4),%r9
xor    %ecx,%ecx
movss  0xd05(%rip),%xmm0
jmp    1313 <main+0x173>
nopl   (%rax)
add    $0x1,%rcx
add    %r9,%rbp
add    %rdx,%r10
cmp    %rdx,%rcx
je     13bb <main+0x21b>
xor    %ebx,%ebx
cmp    $0x3,%r8
jae    136f <main+0x1cf>
test   %rsi,%rsi
je     1300 <main+0x160>
lea    (%rbx,%r10,1),%rax
lea    (%r14,%rax,4),%rax
mov    %rcx,%rdi
sub    %rbx,%rdi
xor    %ebx,%ebx
jmp    134e <main+0x1ae>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  %xmm1,(%rax,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%rsi
je     1300 <main+0x160>
movaps %xmm0,%xmm1
cmp    %rbx,%rdi
je     1340 <main+0x1a0>
xorps  %xmm1,%xmm1
jmp    1340 <main+0x1a0>
nopl   0x0(%rax,%rax,1)
movss  %xmm1,0x0(%rbp,%rbx,4)
add    $0x4,%rbx
cmp    %r11,%rbx
je     131b <main+0x17b>
movaps %xmm0,%xmm1
cmp    %rbx,%rcx
je     137a <main+0x1da>
xorps  %xmm1,%xmm1
movss  %xmm1,-0xc(%rbp,%rbx,4)
lea    0x1(%rbx),%rax
movaps %xmm0,%xmm1
cmp    %rax,%rcx
je     138f <main+0x1ef>
xorps  %xmm1,%xmm1
movss  %xmm1,-0x8(%rbp,%rbx,4)
lea    0x2(%rbx),%rax
movaps %xmm0,%xmm1
cmp    %rax,%rcx
je     13a4 <main+0x204>
xorps  %xmm1,%xmm1
movss  %xmm1,-0x4(%rbp,%rbx,4)
lea    0x3(%rbx),%rax
movaps %xmm0,%xmm1
cmp    %rax,%rcx
je     1360 <main+0x1c0>
xorps  %xmm1,%xmm1
jmp    1360 <main+0x1c0>
lea    (%rdx,%rdx,1),%esi
mov    %r14,%rdi
call   1080 <transpose@plt>
mov    %rax,%rbp
mov    0x4(%rsp),%esi
lea    (%rsi,%rsi,1),%edx
mov    %rax,%rdi
call   1070 <ut@plt>
mov    %r14,%rdi
call   1030 <free@plt>
movslq 0x4(%rsp),%r8
test   %r8,%r8
mov    %rbp,0x20(%rsp)
jle    1417 <main+0x277>
lea    -0x1(%r8),%rcx
mov    %r8d,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    1430 <main+0x290>
movss  0xbf9(%rip),%xmm0
xor    %edx,%edx
test   %rax,%rax
jne    14ab <main+0x30b>
jmp    14dd <main+0x33d>
lea    0xc87(%rip),%rdi
movss  0xbda(%rip),%xmm0
call   1050 <printf@plt>
jmp    1503 <main+0x363>
mov    %r8,%r9
shl    $0x4,%r9
mov    %r8,%rdi
shl    $0x5,%rdi
or     $0x10,%rdi
lea    0x0(,%r8,8),%rcx
mov    %rbp,%rbx
lea    (%rcx,%rcx,2),%rbp
mov    %r8,%rcx
and    $0xfffffffffffffffc,%rcx
neg    %rcx
movss  0xb9d(%rip),%xmm0
mov    $0x1,%edx
nopl   0x0(%rax,%rax,1)
mulss  (%rbx),%xmm0
mulss  0x4(%rbx,%r8,8),%xmm0
mulss  0x8(%rbx,%r9,1),%xmm0
mulss  0xc(%rbx,%rbp,1),%xmm0
add    %rdi,%rbx
lea    (%rcx,%rdx,1),%rsi
add    $0x4,%rsi
add    $0x4,%rdx
cmp    $0x1,%rsi
jne    1470 <main+0x2d0>
add    $0xffffffffffffffff,%rdx
mov    0x20(%rsp),%rbp
test   %rax,%rax
je     14dd <main+0x33d>
lea    (%r8,%r8,1),%rcx
add    $0x1,%rcx
imul   %rcx,%rdx
lea    0x0(,%rdx,4),%rcx
add    %rbp,%rcx
lea    0x4(,%r8,8),%rdx
nopw   0x0(%rax,%rax,1)
mulss  (%rcx),%xmm0
add    %rdx,%rcx
add    $0xffffffffffffffff,%rax
jne    14d0 <main+0x330>
lea    0xbc1(%rip),%rdi
movss  %xmm0,0x8(%rsp)
call   1050 <printf@plt>
xorps  %xmm0,%xmm0
movss  0x8(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    1503 <main+0x363>
jnp    19cc <main+0x82c>
movslq 0x4(%rsp),%rsi
mov    %esi,%eax
mov    %rax,0x8(%rsp)
test   %rsi,%rsi
jle    1975 <main+0x7d5>
mov    0x8(%rsp),%rcx
lea    -0x1(%rcx),%r8d
lea    (%rcx,%rcx,1),%rax
lea    (%rsi,%rsi,1),%rdx
lea    (%r8,%r8,1),%r9
add    $0xffffffffffffffff,%r9
imul   %rcx,%r9
mov    %rax,0x30(%rsp)
neg    %rax
mov    %rax,0x28(%rsp)
lea    -0x8(,%r8,8),%rax
ff
imul   %rcx,%rax
mov    %rax,0xa8(%rsp)
lea    (%r8,%r8,1),%r10
add    $0x1,%r10
imul   %rcx,%r10
mov    %rcx,%r11
imul   %r8,%r11
mov    %rdx,%rdi
sub    %rcx,%rdi
lea    -0x4(%rdi),%rbx
mov    %rbx,0x60(%rsp)
mov    %rbx,%rax
shr    $0x2,%rax
add    $0x1,%rax
mov    %rdi,%r14
and    $0xfffffffffffffffc,%r14
mov    %rax,%rbx
mov    %rax,0x58(%rsp)
and    $0xfffffffffffffffe,%rax
mov    %rax,0x40(%rsp)
mov    %rdi,0x10(%rsp)
mov    %rdi,%r13
and    $0xfffffffffffffff8,%r13
mov    %rdx,%rax
neg    %rax
mov    %rax,0xd0(%rsp)
lea    0x0(,%rcx,8),%rdi
neg    %rdi
lea    (%rdx,%r11,2),%rax
mov    %rax,0x68(%rsp)
lea    0x0(,%r11,8),%r12
add    %rbp,%r12
lea    -0x1(%r8),%rax
imul   %rcx,%rax
lea    0x0(,%rax,8),%r15
add    %rbp,%r15
mov    %r14,0x50(%rsp)
lea    (%r14,%rcx,1),%rax
mov    %rax,0x48(%rsp)
lea    0x0(%r13,%rcx,1),%rax
mov    %rax,0x98(%rsp)
mov    %rdi,%rcx
mov    %r10,0x70(%rsp)
lea    0x10(,%r10,4),%r11
add    %rbp,%r11
mov    %r9,0x78(%rsp)
lea    0x10(,%r9,4),%r14
add    %rbp,%r14
xor    %ebx,%ebx
mov    %r13,0xa0(%rsp)
jmp    167a <main+0x4da>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rdi
lea    -0x1(%rdi),%r8
mov    0x80(%rsp),%rbx
add    $0x1,%rbx
add    %rcx,%r11
add    %rcx,%r12
mov    0x88(%rsp),%r14
add    %rcx,%r14
mov    0x90(%rsp),%r15
add    %rcx,%r15
test   %rdi,%rdi
jle    197c <main+0x7dc>
mov    0x30(%rsp),%rax
imul   %r8,%rax
mov    %rax,0x18(%rsp)
cmp    %edx,%esi
jge    1749 <main+0x5a9>
mov    0x18(%rsp),%rax
add    %r8,%rax
movss  0x0(%rbp,%rax,4),%xmm0
mov    0x8(%rsp),%rax
cmpq   $0x4,0x10(%rsp)
jb     1730 <main+0x590>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x4,0x60(%rsp)
jae    16c2 <main+0x522>
xor    %eax,%eax
jmp    16f6 <main+0x556>
mov    0x40(%rsp),%rdi
xor    %eax,%eax
nopl   0x0(%rax)
movups -0x10(%r11,%rax,4),%xmm2
movups (%r11,%rax,4),%xmm3
divps  %xmm1,%xmm2
movups %xmm2,-0x10(%r11,%rax,4)
divps  %xmm1,%xmm3
movups %xmm3,(%r11,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdi
jne    16d0 <main+0x530>
testb  $0x1,0x58(%rsp)
je     1714 <main+0x574>
add    0x8(%rsp),%rax
add    0x18(%rsp),%rax
movups 0x0(%rbp,%rax,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,0x0(%rbp,%rax,4)
mov    0x48(%rsp),%rax
mov    0x50(%rsp),%rdi
cmp    %rdi,0x10(%rsp)
je     1749 <main+0x5a9>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r12,%rax,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%r12,%rax,4)
add    $0x1,%rax
cmp    %rax,%rdx
jne    1730 <main+0x590>
test   %r8,%r8
jle    197c <main+0x7dc>
mov    %rbp,%r9
mov    0x28(%rsp),%rbp
mov    %rbx,0x80(%rsp)
imul   %rbx,%rbp
mov    0x70(%rsp),%rax
add    %rbp,%rax
mov    0x68(%rsp),%rdi
add    %rbp,%rdi
mov    0x78(%rsp),%rbx
add    %rbp,%rbx
mov    %rbx,0xc8(%rsp)
add    %rdx,%rbp
mov    %rbp,0xb8(%rsp)
mov    %r9,%rbp
lea    (%r9,%rax,4),%rax
mov    %rax,0xb0(%rsp)
lea    (%r9,%rdi,4),%rax
mov    %rax,0xc0(%rsp)
mov    %r15,0x90(%rsp)
mov    %r14,0x88(%rsp)
xor    %r10d,%r10d
mov    %r8,0x38(%rsp)
jmp    17e4 <main+0x644>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r10
add    %rcx,%r14
add    %rcx,%r15
cmp    $0x2,%rdi
jl     1640 <main+0x4a0>
mov    %r8,%rdi
add    $0xffffffffffffffff,%r8
cmp    %edx,%esi
jge    17d0 <main+0x630>
mov    0x30(%rsp),%rax
imul   %r8,%rax
mov    0x38(%rsp),%rbx
add    %rax,%rbx
movss  0x0(%rbp,%rbx,4),%xmm0
mov    0x8(%rsp),%r9
cmpq   $0x8,0x10(%rsp)
jb     18e0 <main+0x740>
mov    0x28(%rsp),%rbx
imul   %r10,%rbx
mov    0xc8(%rsp),%rbp
add    %rbx,%rbp
mov    %rcx,%r13
mov    %rsi,%rcx
mov    0x20(%rsp),%rsi
lea    (%rsi,%rbp,4),%rbp
mov    %rcx,%rsi
cmp    0xc0(%rsp),%rbp
mov    0x20(%rsp),%rbp
jae    1879 <main+0x6d9>
mov    %r13,%rcx
add    0xb8(%rsp),%rbx
lea    0x0(,%rbx,4),%rbx
add    %rbp,%rbx
add    0xa8(%rsp),%rbx
mov    0x8(%rsp),%r9
cmp    0xb0(%rsp),%rbx
ja     18e0 <main+0x740>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
xor    %ebx,%ebx
mov    0xa0(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movups -0x10(%r11,%rbx,4),%xmm2
movups (%r11,%rbx,4),%xmm3
movups -0x10(%r14,%rbx,4),%xmm4
movups (%r14,%rbx,4),%xmm5
mulps  %xmm1,%xmm2
subps  %xmm2,%xmm4
mulps  %xmm1,%xmm3
subps  %xmm3,%xmm5
movups %xmm4,-0x10(%r14,%rbx,4)
movups %xmm5,(%r14,%rbx,4)
add    $0x8,%rbx
cmp    %rbx,%rcx
jne    1890 <main+0x6f0>
mov    0x98(%rsp),%r9
cmp    %rcx,0x10(%rsp)
mov    %r13,%rcx
je     17d0 <main+0x630>
nopl   0x0(%rax)
mov    %r9,%r13
test   $0x1,%r9b
je     1912 <main+0x772>
mov    0x18(%rsp),%rbx
add    %r9,%rbx
add    %r9,%rax
movss  0x0(%rbp,%rax,4),%xmm1
movss  0x0(%rbp,%rbx,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x0(%rbp,%rax,4)
lea    0x1(%r9),%r13
not    %r9
cmp    0xd0(%rsp),%r9
je     17d0 <main+0x630>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%r12,%r13,4),%xmm1
mulss  %xmm0,%xmm1
movss  (%r15,%r13,4),%xmm2
subss  %xmm1,%xmm2
movss  0x4(%r15,%r13,4),%xmm1
movss  %xmm2,(%r15,%r13,4)
movss  0x4(%r12,%r13,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x4(%r15,%r13,4)
add    $0x2,%r13
cmp    %r13,%rdx
jne    1930 <main+0x790>
jmp    17d0 <main+0x630>
mov    0x8(%rsp),%rdx
add    %edx,%edx
mov    %rbp,%rdi
call   1080 <transpose@plt>
mov    %rax,%r14
mov    0x4(%rsp),%edx
mov    %edx,%eax
imul   %eax,%eax
lea    (%r14,%rax,4),%rdi
mov    %edx,%esi
call   1080 <transpose@plt>
mov    %rax,%rbx
lea    0x749(%rip),%rdi
call   1040 <puts@plt>
mov    0x4(%rsp),%ecx
lea    0x6ea(%rip),%rdi
mov    %rbx,%rsi
mov    %ecx,%edx
call   10c0 <printmatf@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
jmp    19db <main+0x83b>
lea    0x6f7(%rip),%rdi
call   1040 <puts@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [44 x i8] c"Please input the size of the square matrix:\00"
@.str.1 = [5 x i8] c"n = \00"
@stdout = global i32 0
@.str.2 = [3 x i8] c"%d\00"
@.str.3 = [29 x i8] c"Now please input the matrix:\00"
@.str.4 = [3 x i8] c"%f\00"
@.str.5 = [42 x i8] c"The sum of all the matrix elements: %.2f\0A\00"
@.str.6 = [29 x i8] c"The transpose of the matrix:\00"
@.str.7 = [6 x i8] c"%8.3f\00"
@.str.8 = [37 x i8] c"The determinant of the matrix: %.2f\0A\00"
@.str.9 = [36 x i8] c"The given matrix is not invertible.\00"
@.str.10 = [27 x i8] c"The inverse of the matrix:\00"
define i32 @main() {
%1 = alloca i32
%2 = bitcast i32* %1 to i8*
%3 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0))
%4 = load i32, i32* @stdout
%5 = tail call i32 @fputs(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 %4)
%6 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i32* %1)
%7 = load i32, i32* %1
%8 = mul nsw i32 %7, %7
%9 = zext i32 %8 to i64
%10 = shl nuw nsw i64 %9, 2
%11 = call float* @malloc(i64 %10)
%12 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0))
%13 = load i32, i32* %1
%14 = mul nsw i32 %13, %13
%15 = icmp eq i32 %14, 0
br i1 %15, label %28, label %16
16: ; preds = %0, %16
%17 = phi i64 [ %23, %16 ], [ 0, %0 ]
%18 = phi float [ %22, %16 ], [ 0.000000e+00, %0 ]
%19 = getelementptr inbounds float, float* %11, i64 %17
%20 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), float* %19)
%21 = load float, float* %19
%22 = fadd float %18, %21
%23 = add nuw nsw i64 %17, 1
%24 = load i32, i32* %1
%25 = mul nsw i32 %24, %24
%26 = zext i32 %25 to i64
%27 = icmp ult i64 %23, %26
br i1 %27, label %16, label %28
28: ; preds = %16, %0
%29 = phi float [ 0.000000e+00, %0 ], [ %22, %16 ]
%30 = call i32 @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.5, i64 0, i64 0), float %29)
%31 = load i32, i32* %1
%32 = call float* @transpose(float* %11, i32 %31, i32 %31)
%33 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.6, i64 0, i64 0))
%34 = load i32, i32* %1
%35 = call i32 @printmatf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0), float* %32, i32 %34, i32 %34)
%36 = call i32 @free(float* %11)
%37 = shl nuw nsw i64 %9, 3
%38 = call float* @realloc(float* %32, i64 %37)
%39 = load i32, i32* %1
%40 = sext i32 %39 to i64
%41 = icmp sgt i32 %39, 0
br i1 %41, label %42, label %94
42: ; preds = %28
%43 = mul nsw i32 %39, %39
%44 = zext i32 %43 to i64
%45 = add nsw i64 %40, -1
%46 = and i64 %40, 3
%47 = icmp ult i64 %45, 3
%48 = and i64 %40, -4
%49 = icmp eq i64 %46, 0
br label %50
50: ; preds = %91, %42
%51 = phi i64 [ 0, %42 ], [ %92, %91 ]
%52 = mul nsw i64 %51, %40
%53 = add nsw i64 %52, %44
br i1 %47, label %79, label %54
54: ; preds = %50, %54
%55 = phi i64 [ %76, %54 ], [ 0, %50 ]
%56 = phi i64 [ %77, %54 ], [ 0, %50 ]
%57 = icmp eq i64 %51, %55
%58 = uitofp i1 %57 to float
%59 = add nsw i64 %53, %55
%60 = getelementptr inbounds float, float* %38, i64 %59
store float %58, float* %60
%61 = or i64 %55, 1
%62 = icmp eq i64 %51, %61
%63 = uitofp i1 %62 to float
%64 = add nsw i64 %53, %61
%65 = getelementptr inbounds float, float* %38, i64 %64
store float %63, float* %65
%66 = or i64 %55, 2
%67 = icmp eq i64 %51, %66
%68 = uitofp i1 %67 to float
%69 = add nsw i64 %53, %66
%70 = getelementptr inbounds float, float* %38, i64 %69
store float %68, float* %70
%71 = or i64 %55, 3
%72 = icmp eq i64 %51, %71
%73 = uitofp i1 %72 to float
%74 = add nsw i64 %53, %71
%75 = getelementptr inbounds float, float* %38, i64 %74
store float %73, float* %75
%76 = add nuw nsw i64 %55, 4
%77 = add i64 %56, 4
%78 = icmp eq i64 %77, %48
br i1 %78, label %79, label %54
79: ; preds = %54, %50
%80 = phi i64 [ 0, %50 ], [ %76, %54 ]
br i1 %49, label %91, label %81
81: ; preds = %79, %81
%82 = phi i64 [ %88, %81 ], [ %80, %79 ]
%83 = phi i64 [ %89, %81 ], [ 0, %79 ]
%84 = icmp eq i64 %51, %82
%85 = uitofp i1 %84 to float
%86 = add nsw i64 %53, %82
%87 = getelementptr inbounds float, float* %38, i64 %86
store float %85, float* %87
%88 = add nuw nsw i64 %82, 1
%89 = add i64 %83, 1
%90 = icmp eq i64 %89, %46
br i1 %90, label %91, label %81
91: ; preds = %81, %79
%92 = add nuw nsw i64 %51, 1
%93 = icmp eq i64 %92, %40
br i1 %93, label %94, label %50
94: ; preds = %91, %28
%95 = shl nsw i32 %39, 1
%96 = call float* @transpose(float* %38, i32 %95, i32 %39)
%97 = load i32, i32* %1
%98 = shl nsw i32 %97, 1
%99 = call i32 @ut(float* %96, i32 %97, i32 %98)
%100 = call i32 @free(float* %38)
%101 = load i32, i32* %1
%102 = sext i32 %101 to i64
%103 = icmp sgt i32 %101, 0
br i1 %103, label %104, label %110
104: ; preds = %94
%105 = add nsw i64 %102, -1
%106 = and i64 %102, 3
%107 = icmp ult i64 %105, 3
br i1 %107, label %146, label %108
108: ; preds = %104
%109 = and i64 %102, -4
br label %112
110: ; preds = %94
%111 = call i32 @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.8, i64 0, i64 0), float 1.000000e+00)
br label %171
112: ; preds = %112, %108
%113 = phi i64 [ 0, %108 ], [ %143, %112 ]
%114 = phi float [ 1.000000e+00, %108 ], [ %142, %112 ]
%115 = phi i64 [ 0, %108 ], [ %144, %112 ]
%116 = shl nuw i64 %113, 1
%117 = mul i64 %116, %102
%118 = add nsw i64 %117, %113
%119 = getelementptr inbounds float, float* %96, i64 %118
%120 = load float, float* %119
%121 = fmul float %114, %120
%122 = or i64 %113, 1
%123 = shl nuw i64 %122, 1
%124 = mul i64 %123, %102
%125 = add nsw i64 %124, %122
%126 = getelementptr inbounds float, float* %96, i64 %125
%127 = load float, float* %126
%128 = fmul float %121, %127
%129 = or i64 %113, 2
%130 = shl nuw i64 %129, 1
%131 = mul i64 %130, %102
%132 = add nsw i64 %131, %129
%133 = getelementptr inbounds float, float* %96, i64 %132
%134 = load float, float* %133
%135 = fmul float %128, %134
%136 = or i64 %113, 3
%137 = shl nuw i64 %136, 1
%138 = mul i64 %137, %102
%139 = add nsw i64 %138, %136
%140 = getelementptr inbounds float, float* %96, i64 %139
%141 = load float, float* %140
%142 = fmul float %135, %141
%143 = add nuw nsw i64 %113, 4
%144 = add i64 %115, 4
%145 = icmp eq i64 %144, %109
br i1 %145, label %146, label %112
146: ; preds = %112, %104
%147 = phi float [ undef, %104 ], [ %142, %112 ]
%148 = phi i64 [ 0, %104 ], [ %143, %112 ]
%149 = phi float [ 1.000000e+00, %104 ], [ %142, %112 ]
%150 = icmp eq i64 %106, 0
br i1 %150, label %164, label %151
151: ; preds = %146, %151
%152 = phi i64 [ %161, %151 ], [ %148, %146 ]
%153 = phi float [ %160, %151 ], [ %149, %146 ]
%154 = phi i64 [ %162, %151 ], [ 0, %146 ]
%155 = shl nuw i64 %152, 1
%156 = mul i64 %155, %102
%157 = add nsw i64 %156, %152
%158 = getelementptr inbounds float, float* %96, i64 %157
%159 = load float, float* %158
%160 = fmul float %153, %159
%161 = add nuw nsw i64 %152, 1
%162 = add i64 %154, 1
%163 = icmp eq i64 %162, %106
br i1 %163, label %164, label %151
164: ; preds = %151, %146
%165 = phi float [ %147, %146 ], [ %160, %151 ]
%166 = call i32 @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.8, i64 0, i64 0), float %165)
%167 = fcmp une float %165, 0.000000e+00
br i1 %167, label %171, label %168
168: ; preds = %164
%169 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.9, i64 0, i64 0))
%170 = call i32 @free(float* %96)
br label %386
171: ; preds = %110, %164
%172 = load i32, i32* %1
%173 = icmp sgt i32 %172, 0
br i1 %173, label %176, label %174
174: ; preds = %171
%175 = shl nsw i32 %172, 1
br label %373
176: ; preds = %171
%177 = add nsw i32 %172, -1
%178 = zext i32 %177 to i64
%179 = zext i32 %172 to i64
%180 = shl nuw nsw i64 %179, 1
%181 = shl nuw nsw i32 %172, 1
%182 = sext i32 %181 to i64
%183 = icmp slt i32 %172, %181
%184 = shl nuw nsw i64 %178, 1
%185 = add nsw i64 %184, -1
%186 = mul i64 %185, %179
%187 = mul nsw i64 %179, -2
%188 = mul nsw i64 %179, -2
%189 = shl nuw nsw i64 %178, 3
%190 = add nsw i64 %189, -8
%191 = mul i64 %190, %179
%192 = or i64 %184, 1
%193 = mul i64 %192, %179
%194 = mul nuw i64 %179, %178
%195 = shl i64 %194, 1
%196 = add i64 %195, %182
%197 = sub nsw i64 %182, %179
%198 = add nsw i64 %197, -4
%199 = lshr i64 %198, 2
%200 = add nuw nsw i64 %199, 1
%201 = icmp ult i64 %197, 4
%202 = and i64 %197, -4
%203 = add nsw i64 %202, %179
%204 = and i64 %200, 1
%205 = icmp ult i64 %198, 4
%206 = and i64 %200, 9223372036854775806
%207 = icmp eq i64 %204, 0
%208 = icmp eq i64 %197, %202
%209 = icmp ult i64 %197, 8
%210 = and i64 %197, -8
%211 = add nsw i64 %210, %179
%212 = icmp eq i64 %197, %210
%213 = sub nsw i64 0, %182
br label %214
214: ; preds = %176, %370
%215 = phi i64 [ 0, %176 ], [ %372, %370 ]
%216 = phi i64 [ %178, %176 ], [ %371, %370 ]
%217 = mul i64 %187, %215
%218 = add i64 %186, %217
%219 = add i64 %217, %182
%220 = add i64 %193, %217
%221 = getelementptr float, float* %96, i64 %220
%222 = bitcast float* %221 to i8*
%223 = add i64 %196, %217
%224 = getelementptr float, float* %96, i64 %223
%225 = mul i64 %180, %216
%226 = add nsw i64 %225, %216
%227 = getelementptr inbounds float, float* %96, i64 %226
%228 = load float, float* %227
br i1 %183, label %229, label %267
229: ; preds = %214
br i1 %201, label %265, label %230
230: ; preds = %229
%231 = insertelement <4 x float> poison, float %228, i64 0
%232 = shufflevector <4 x float> %231, <4 x float> poison, <4 x i32> zeroinitializer
br i1 %205, label %254, label %233
233: ; preds = %230, %233
%234 = phi i64 [ %251, %233 ], [ 0, %230 ]
%235 = phi i64 [ %252, %233 ], [ 0, %230 ]
%236 = add i64 %234, %179
%237 = add nsw i64 %236, %225
%238 = getelementptr inbounds float, float* %96, i64 %237
%239 = bitcast float* %238 to <4 x float>*
%240 = load <4 x float>, <4 x float>* %239
%241 = fdiv <4 x float> %240, %232
%242 = bitcast float* %238 to <4 x float>*
store <4 x float> %241, <4 x float>* %242
%243 = or i64 %234, 4
%244 = add i64 %243, %179
%245 = add nsw i64 %244, %225
%246 = getelementptr inbounds float, float* %96, i64 %245
%247 = bitcast float* %246 to <4 x float>*
%248 = load <4 x float>, <4 x float>* %247
%249 = fdiv <4 x float> %248, %232
%250 = bitcast float* %246 to <4 x float>*
store <4 x float> %249, <4 x float>* %250
%251 = add nuw i64 %234, 8
%252 = add i64 %235, 2
%253 = icmp eq i64 %252, %206
br i1 %253, label %254, label %233
254: ; preds = %233, %230
%255 = phi i64 [ 0, %230 ], [ %251, %233 ]
br i1 %207, label %264, label %256
256: ; preds = %254
%257 = add i64 %255, %179
%258 = add nsw i64 %257, %225
%259 = getelementptr inbounds float, float* %96, i64 %258
%260 = bitcast float* %259 to <4 x float>*
%261 = load <4 x float>, <4 x float>* %260
%262 = fdiv <4 x float> %261, %232
%263 = bitcast float* %259 to <4 x float>*
store <4 x float> %262, <4 x float>* %263
br label %264
264: ; preds = %254, %256
br i1 %208, label %267, label %265
265: ; preds = %229, %264
%266 = phi i64 [ %179, %229 ], [ %203, %264 ]
br label %269
267: ; preds = %269, %264, %214
%268 = icmp sgt i64 %216, 0
br i1 %268, label %280, label %373
269: ; preds = %265, %269
%270 = phi i64 [ %275, %269 ], [ %266, %265 ]
%271 = add nsw i64 %270, %225
%272 = getelementptr inbounds float, float* %96, i64 %271
%273 = load float, float* %272
%274 = fdiv float %273, %228
store float %274, float* %272
%275 = add nuw nsw i64 %270, 1
%276 = icmp eq i64 %275, %182
br i1 %276, label %267, label %269
277: ; preds = %346, %349, %330, %280
%278 = icmp sgt i64 %282, 1
%279 = add i64 %281, 1
br i1 %278, label %280, label %370
280: ; preds = %267, %277
%281 = phi i64 [ %279, %277 ], [ 0, %267 ]
%282 = phi i64 [ %290, %277 ], [ %216, %267 ]
%283 = mul i64 %188, %281
%284 = add i64 %218, %283
%285 = getelementptr float, float* %96, i64 %284
%286 = add i64 %219, %283
%287 = getelementptr float, float* %96, i64 %286
%288 = bitcast float* %287 to i8*
%289 = getelementptr i8, i8* %288, i64 %191
%290 = add nsw i64 %282, -1
%291 = mul i64 %180, %290
%292 = add nsw i64 %291, %216
%293 = getelementptr inbounds float, float* %96, i64 %292
%294 = load float, float* %293
br i1 %183, label %295, label %277
295: ; preds = %280
br i1 %209, label %331, label %296
296: ; preds = %295
%297 = icmp ult float* %285, %224
%298 = icmp ugt i8* %289, %222
%299 = and i1 %297, %298
br i1 %299, label %331, label %300
300: ; preds = %296
%301 = insertelement <4 x float> poison, float %294, i64 0
%302 = shufflevector <4 x float> %301, <4 x float> poison, <4 x i32> zeroinitializer
%303 = insertelement <4 x float> poison, float %294, i64 0
%304 = shufflevector <4 x float> %303, <4 x float> poison, <4 x i32> zeroinitializer
br label %305
305: ; preds = %305, %300
%306 = phi i64 [ 0, %300 ], [ %328, %305 ]
%307 = add i64 %306, %179
%308 = add nsw i64 %307, %225
%309 = getelementptr inbounds float, float* %96, i64 %308
%310 = bitcast float* %309 to <4 x float>*
%311 = load <4 x float>, <4 x float>* %310
%312 = getelementptr inbounds float, float* %309, i64 4
%313 = bitcast float* %312 to <4 x float>*
%314 = load <4 x float>, <4 x float>* %313
%315 = add nsw i64 %307, %291
%316 = getelementptr inbounds float, float* %96, i64 %315
%317 = bitcast float* %316 to <4 x float>*
%318 = load <4 x float>, <4 x float>* %317
%319 = getelementptr inbounds float, float* %316, i64 4
%320 = bitcast float* %319 to <4 x float>*
%321 = load <4 x float>, <4 x float>* %320
%322 = fneg <4 x float> %311
%323 = fneg <4 x float> %314
%324 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %322, <4 x float> %302, <4 x float> %318)
%325 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %323, <4 x float> %304, <4 x float> %321)
%326 = bitcast float* %316 to <4 x float>*
store <4 x float> %324, <4 x float>* %326
%327 = bitcast float* %319 to <4 x float>*
store <4 x float> %325, <4 x float>* %327
%328 = add nuw i64 %306, 8
%329 = icmp eq i64 %328, %210
br i1 %329, label %330, label %305
330: ; preds = %305
br i1 %212, label %277, label %331
331: ; preds = %296, %295, %330
%332 = phi i64 [ %179, %296 ], [ %179, %295 ], [ %211, %330 ]
%333 = xor i64 %332, -1
%334 = and i64 %332, 1
%335 = icmp eq i64 %334, 0
br i1 %335, label %346, label %336
336: ; preds = %331
%337 = add nsw i64 %332, %225
%338 = getelementptr inbounds float, float* %96, i64 %337
%339 = load float, float* %338
%340 = add nsw i64 %332, %291
%341 = getelementptr inbounds float, float* %96, i64 %340
%342 = load float, float* %341
%343 = fneg float %339
%344 = call float @llvm.fmuladd.f32(float %343, float %294, float %342)
store float %344, float* %341
%345 = add nuw nsw i64 %332, 1
br label %346
346: ; preds = %336, %331
%347 = phi i64 [ %332, %331 ], [ %345, %336 ]
%348 = icmp eq i64 %333, %213
br i1 %348, label %277, label %349
349: ; preds = %346, %349
%350 = phi i64 [ %368, %349 ], [ %347, %346 ]
%351 = add nsw i64 %350, %225
%352 = getelementptr inbounds float, float* %96, i64 %351
%353 = load float, float* %352
%354 = add nsw i64 %350, %291
%355 = getelementptr inbounds float, float* %96, i64 %354
%356 = load float, float* %355
%357 = fneg float %353
%358 = call float @llvm.fmuladd.f32(float %357, float %294, float %356)
store float %358, float* %355
%359 = add nuw nsw i64 %350, 1
%360 = add nsw i64 %359, %225
%361 = getelementptr inbounds float, float* %96, i64 %360
%362 = load float, float* %361
%363 = add nsw i64 %359, %291
%364 = getelementptr inbounds float, float* %96, i64 %363
%365 = load float, float* %364
%366 = fneg float %362
%367 = call float @llvm.fmuladd.f32(float %366, float %294, float %365)
store float %367, float* %364
%368 = add nuw nsw i64 %350, 2
%369 = icmp eq i64 %368, %182
br i1 %369, label %277, label %349
370: ; preds = %277
%371 = add nsw i64 %216, -1
%372 = add i64 %215, 1
br i1 %268, label %214, label %373
373: ; preds = %267, %370, %174
%374 = phi i32 [ %175, %174 ], [ %181, %370 ], [ %181, %267 ]
%375 = call float* @transpose(float* %96, i32 %172, i32 %374)
%376 = load i32, i32* %1
%377 = mul nsw i32 %376, %376
%378 = zext i32 %377 to i64
%379 = getelementptr inbounds float, float* %375, i64 %378
%380 = call float* @transpose(float* %379, i32 %376, i32 %376)
%381 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.10, i64 0, i64 0))
%382 = load i32, i32* %1
%383 = call i32 @printmatf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0), float* %380, i32 %382, i32 %382)
%384 = call i32 @free(float* %380)
%385 = call i32 @free(float* %375)
br label %386
386: ; preds = %373, %168
ret i32 0
}