#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 atoi(char *);
int /*<<< orphan*/ difftime(double, double);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fread(double *, int, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ free(double *);
int /*<<< orphan*/ fwrite(double *, int, int, int /*<<< orphan*/ *);
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *, ...);
double time(int /*<<< orphan*/);
int main(int argc, char *argv[]) {
  double start, stop;
  double *matrix;
  double *col, *row;
  char *filename;
  FILE *fp;
  int i, j, k, n;
  if (argc <= 1) {
    printf("./xxx vector_size input_filename\n");
    return 1;
  } else {
    n = atoi(argv[1]);
  }
  if ((fp = fopen("input.data", "r")) == NULL) {
    printf("fopen read error\n");
    return 1;
  }
  matrix = (double *)malloc(sizeof(double) * n * n);
  fread(matrix, sizeof(double), n * n, fp);
  fclose(fp);
  col = (double *)malloc(sizeof(double) * n);
  row = (double *)malloc(sizeof(double) * n);
  start = time(0);
  for (k = 0; k < n - 1; k++) {
    for (i = k; i < n; i++)
      col[i] = matrix[i * n + k];
    for (i = k + 1; i < n; i++)
      matrix[k * n + i] /= col[k];
    for (i = k + 1; i < n; i++)
      row[i] = matrix[k * n + i];
    for (i = k + 1; i < n; i++) {
      for (j = k + 1; j < n; j++) {
        matrix[i * n + j] -= col[i] * row[j];
      }
    }
  }
  stop = time(0);
  printf("Completed decomposition in %.3lf seconds\n", difftime(stop, start));
  if ((fp = fopen("seqence.data", "w")) == NULL) {
    printf("fopen read error\n");
    return 1;
  }
  fwrite(matrix, sizeof(double), n * n, fp);
  fclose(fp);
  free(col);
  free(row);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0x1,-0x8(%rbp)
jg     11da <main+0x3a>
lea    0xe39(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    14d7 <main+0x337>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   10b0 <atoi@plt>
mov    %eax,-0x58(%rbp)
lea    0xe31(%rip),%rdi
lea    0xe35(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,-0x48(%rbp)
cmp    $0x0,%rax
jne    1225 <main+0x85>
lea    0xe1d(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    14d7 <main+0x337>
movslq -0x58(%rbp),%rax
shl    $0x3,%rax
movslq -0x58(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rdi
mov    -0x58(%rbp),%edx
imul   -0x58(%rbp),%edx
mov    -0x48(%rbp),%rcx
mov    $0x8,%esi
call   1040 <fread@plt>
mov    -0x48(%rbp),%rdi
call   1050 <fclose@plt>
movslq -0x58(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x30(%rbp)
movslq -0x58(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x38(%rbp)
xor    %edi,%edi
call   1080 <time@plt>
movsd  %xmm0,-0x18(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1436 <main+0x296>
mov    -0x54(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    12ef <main+0x14f>
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12b2 <main+0x112>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    133e <main+0x19e>
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12f8 <main+0x158>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    1384 <main+0x1e4>
mov    -0x28(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1347 <main+0x1a7>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    1423 <main+0x283>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    1410 <main+0x270>
mov    -0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    13a2 <main+0x202>
jmp    1415 <main+0x275>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    138d <main+0x1ed>
jmp    1428 <main+0x288>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    129b <main+0xfb>
xor    %edi,%edi
call   1080 <time@plt>
movsd  %xmm0,-0x20(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm1
call   1070 <difftime@plt>
mov    %eax,%esi
lea    0xbe7(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xc03(%rip),%rdi
lea    0xc09(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,-0x48(%rbp)
cmp    $0x0,%rax
jne    149c <main+0x2fc>
lea    0xba6(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    14d7 <main+0x337>
mov    -0x28(%rbp),%rdi
mov    -0x58(%rbp),%edx
imul   -0x58(%rbp),%edx
mov    -0x48(%rbp),%rcx
mov    $0x8,%esi
call   10c0 <fwrite@plt>
mov    -0x48(%rbp),%rdi
call   1050 <fclose@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
cmp    $0x1,%edi
jg     11d2 <main+0x22>
lea    0xe98(%rip),%rdi
jmp    19e1 <main+0x831>
mov    0x8(%rsi),%rdi
call   10c0 <atoi@plt>
mov    %eax,%r12d
lea    0xe2b(%rip),%rdi
lea    0xe77(%rip),%rsi
call   10b0 <fopen@plt>
test   %rax,%rax
je     19da <main+0x82a>
mov    %rax,%rbx
lea    0x0(,%r12,8),%r14d
mov    %r14d,%edi
imul   %r12d,%edi
call   10a0 <malloc@plt>
mov    %rax,%rbp
mov    %r12d,%edx
imul   %r12d,%edx
mov    %rax,%rdi
mov    $0x8,%esi
mov    %edx,0x44(%rsp)
mov    %rbx,%rcx
call   1050 <fread@plt>
mov    %rbx,%rdi
call   1060 <fclose@plt>
mov    %r14d,%edi
call   10a0 <malloc@plt>
mov    %rax,%r15
mov    %r14d,%edi
mov    %rbp,%r14
call   10a0 <malloc@plt>
mov    %rax,%rbx
xor    %edi,%edi
call   1090 <time@plt>
movsd  %xmm0,0x98(%rsp)
cmp    $0x2,%r12d
mov    %rbp,0x88(%rsp)
jl     1965 <main+0x7b5>
mov    %r12d,%r9d
add    $0xffffffff,%r12d
lea    0x1(%r9),%rax
mov    %rax,0xd8(%rsp)
lea    0x0(,%r9,8),%rax
lea    0x8(,%r9,8),%rcx
mov    %rcx,0x78(%rsp)
lea    (%rbx,%r9,8),%rcx
mov    %rcx,0x90(%rsp)
lea    0x8(%r14),%rcx
mov    %rcx,0xa0(%rsp)
lea    -0x1(%r9),%rcx
mov    %r9,%rdx
neg    %rdx
mov    %rdx,0xe8(%rsp)
lea    -0x3(%r9),%rdx
mov    %rdx,0x58(%rsp)
lea    0x38(%rbx),%rdx
lea    -0x5(%r9),%rsi
mov    %rsi,0x50(%rsp)
lea    0x18(%rbx),%r8
lea    0x18(%r14,%r9,8),%rsi
mov    %rsi,0x70(%rsp)
lea    0x8(%r14,%r9,8),%rsi
mov    %rsi,0x68(%rsp)
mov    $0x1,%r13d
movapd 0xd00(%rip),%xmm0
xor    %esi,%esi
mov    %rcx,0x48(%rsp)
mov    %rcx,0x60(%rsp)
mov    %r14,0x20(%rsp)
mov    %r9,%rdi
mov    %r15,%rbp
mov    %r14,%r10
mov    %r12,0xb0(%rsp)
mov    %rax,0xf0(%rsp)
jmp    13a0 <main+0x1f0>
nopl   0x0(%rax)
add    $0x1,%r13
mov    0x78(%rsp),%rcx
mov    0x30(%rsp),%r10
add    %rcx,%r10
mov    0xc8(%rsp),%rbp
add    $0x8,%rbp
mov    0xd0(%rsp),%rdi
add    $0xffffffffffffffff,%rdi
addq   $0xffffffffffffffff,0x58(%rsp)
add    %rax,0x20(%rsp)
mov    0x80(%rsp),%rdx
add    $0x8,%rdx
addq   $0xffffffffffffffff,0x50(%rsp)
addq   $0xffffffffffffffff,0x60(%rsp)
add    $0x8,%r8
add    %rcx,0x70(%rsp)
add    %rax,0x68(%rsp)
mov    0xb0(%rsp),%r12
mov    0x8(%rsp),%rsi
cmp    %r12,%rsi
je     1965 <main+0x7b5>
mov    %rdx,0x80(%rsp)
mov    %rsi,%rdx
cmp    %r9,%rsi
jae    13d6 <main+0x226>
xor    %ecx,%ecx
mov    %r10,%rsi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rsi),%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
add    %rax,%rsi
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    13c0 <main+0x210>
mov    %rbp,0xc8(%rsp)
mov    %rdi,0xd0(%rsp)
lea    0x1(%rdx),%rcx
mov    %rcx,0x8(%rsp)
cmp    %r9,%rcx
mov    %r10,0x30(%rsp)
jae    1330 <main+0x180>
mov    %rdx,%r11
mov    %rdx,%rbp
imul   %r9,%rdx
mov    %r11,%rcx
not    %rcx
mov    0x78(%rsp),%rdi
imul   %r11,%rdi
mov    %rdx,%rsi
mov    %rdx,0x18(%rsp)
lea    (%rdx,%r9,1),%r12
lea    (%rcx,%r9,1),%rdx
mov    0xa0(%rsp),%rsi
mov    %rdi,0xa8(%rsp)
lea    (%rsi,%rdi,1),%r10
lea    (%r14,%r12,8),%rsi
mov    %r13,%rdi
mov    %rdx,0x10(%rsp)
cmp    $0x2,%rdx
jb     1520 <main+0x370>
lea    (%r15,%r13,8),%rdx
cmp    %rdx,%r10
jae    1469 <main+0x2b9>
lea    (%r15,%rbp,8),%rdx
mov    %r13,%rdi
cmp    %rsi,%rdx
jb     1520 <main+0x370>
mov    %rsi,0x28(%rsp)
add    %r9,%rcx
add    $0xfffffffffffffffe,%rcx
mov    %rcx,%r12
shr    %r12
add    $0x1,%r12
cmp    $0x2,%rcx
jae    1489 <main+0x2d9>
xor    %esi,%esi
jmp    14da <main+0x32a>
mov    0x58(%rsp),%rcx
shr    %rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
movsd  (%r15,%r11,8),%xmm1
unpcklpd %xmm1,%xmm1
xor    %esi,%esi
mov    0x30(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
movupd 0x8(%rdx,%rsi,8),%xmm2
movupd 0x18(%rdx,%rsi,8),%xmm3
divpd  %xmm1,%xmm2
movupd %xmm2,0x8(%rdx,%rsi,8)
divpd  %xmm1,%xmm3
movupd %xmm3,0x18(%rdx,%rsi,8)
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rcx
jne    14b0 <main+0x300>
mov    0x10(%rsp),%rcx
mov    %rcx,%rdi
and    $0xfffffffffffffffe,%rdi
test   $0x1,%r12b
mov    %r11,%rbp
je     1511 <main+0x361>
add    %r13,%rsi
movsd  (%r15,%rbp,8),%xmm1
unpcklpd %xmm1,%xmm1
add    0x18(%rsp),%rsi
movupd (%r14,%rsi,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%r14,%rsi,8)
cmp    %rdi,%rcx
mov    0x28(%rsp),%rsi
je     158b <main+0x3db>
add    %r13,%rdi
xchg   %ax,%ax
mov    %r9d,%edx
sub    %edi,%edx
mov    %rdi,%rcx
test   $0x1,%dl
je     154b <main+0x39b>
mov    0x18(%rsp),%rcx
add    %rdi,%rcx
movsd  (%r14,%rcx,8),%xmm1
divsd  (%r15,%rbp,8),%xmm1
movsd  %xmm1,(%r14,%rcx,8)
lea    0x1(%rdi),%rcx
cmp    %rdi,0x48(%rsp)
mov    0x20(%rsp),%rdx
je     158b <main+0x3db>
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rcx,8),%xmm1
divsd  (%r15,%rbp,8),%xmm1
movsd  0x8(%rdx,%rcx,8),%xmm2
movsd  %xmm1,(%rdx,%rcx,8)
divsd  (%r15,%rbp,8),%xmm2
movsd  %xmm2,0x8(%rdx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    1560 <main+0x3b0>
cmp    %r9,0x8(%rsp)
jae    1330 <main+0x180>
lea    (%rbx,%r13,8),%rcx
mov    %rcx,0x28(%rsp)
mov    %r13,%rdi
cmpq   $0x4,0x10(%rsp)
jb     16a0 <main+0x4f0>
cmp    %rsi,0x28(%rsp)
jae    15c6 <main+0x416>
mov    %r13,%rdi
cmp    0x90(%rsp),%r10
jb     16a0 <main+0x4f0>
mov    0x48(%rsp),%rcx
mov    %r11,%rdx
sub    %r11,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,%r10
shr    $0x2,%r10
add    $0x1,%r10
cmp    $0x4,%rcx
jae    15ef <main+0x43f>
xor    %esi,%esi
mov    0x8(%rsp),%rbp
jmp    1655 <main+0x4a5>
mov    0x50(%rsp),%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %esi,%esi
mov    0x80(%rsp),%rdx
mov    0x8(%rsp),%rbp
mov    0x30(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups 0x8(%rdi,%rsi,8),%xmm1
movups 0x18(%rdi,%rsi,8),%xmm2
movups %xmm1,-0x30(%rdx,%rsi,8)
movups %xmm2,-0x20(%rdx,%rsi,8)
movupd 0x28(%rdi,%rsi,8),%xmm1
movupd 0x38(%rdi,%rsi,8),%xmm2
movupd %xmm1,-0x10(%rdx,%rsi,8)
movupd %xmm2,(%rdx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rcx
jne    1620 <main+0x470>
mov    0x10(%rsp),%rcx
mov    %rcx,%rdi
and    $0xfffffffffffffffc,%rdi
test   $0x1,%r10b
je     168a <main+0x4da>
add    %r13,%rsi
mov    0x18(%rsp),%rdx
add    %rsi,%rdx
movupd (%r14,%rdx,8),%xmm1
movupd 0x10(%r14,%rdx,8),%xmm2
movupd %xmm1,(%rbx,%rsi,8)
movupd %xmm2,0x10(%rbx,%rsi,8)
cmp    %rdi,%rcx
je     1727 <main+0x577>
add    %r13,%rdi
cs nopw 0x0(%rax,%rax,1)
mov    %r9d,%esi
sub    %edi,%esi
mov    %rdi,%rcx
not    %rcx
add    %r9,%rcx
and    $0x3,%rsi
je     194c <main+0x79c>
mov    0x20(%rsp),%rdx
mov    0x8(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdx,%rdi,8),%xmm1
movsd  %xmm1,(%rbx,%rdi,8)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rsi
jne    16d0 <main+0x520>
cmp    $0x3,%rcx
jb     1727 <main+0x577>
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rdi,8),%xmm1
movsd  %xmm1,(%rbx,%rdi,8)
movsd  0x8(%rdx,%rdi,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rdi,8)
movsd  0x10(%rdx,%rdi,8),%xmm1
movsd  %xmm1,0x10(%rbx,%rdi,8)
movsd  0x18(%rdx,%rdi,8),%xmm1
movsd  %xmm1,0x18(%rbx,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%r9
jne    16f0 <main+0x540>
cmp    %r9,%rbp
mov    0xa8(%rsp),%rbp
jae    1330 <main+0x180>
mov    %r11,%rcx
add    $0x2,%rcx
mov    0x60(%rsp),%r11
and    $0xfffffffffffffffc,%r11
mov    %rcx,0x18(%rsp)
imul   %r9,%rcx
mov    %rcx,0xe0(%rsp)
mov    0x10(%rsp),%rcx
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0xc0(%rsp)
add    %r13,%rcx
mov    %rcx,0xb8(%rsp)
mov    0x68(%rsp),%r12
mov    0x70(%rsp),%rdi
xor    %esi,%esi
mov    %r13,%r10
mov    %r13,0x38(%rsp)
jmp    17b4 <main+0x604>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10
add    $0x1,%rsi
mov    0xf0(%rsp),%rax
add    %rax,%rdi
add    %rax,%r12
cmp    %r9,%r10
mov    0x38(%rsp),%r13
je     1330 <main+0x180>
mov    %r13,%rcx
cmpq   $0x4,0x10(%rsp)
jae    1860 <main+0x6b0>
mov    %r9d,%eax
sub    %ecx,%eax
mov    %rcx,%r13
test   $0x1,%al
je     17f8 <main+0x648>
mov    %r10,%rax
imul   %r9,%rax
movsd  (%r15,%r10,8),%xmm1
add    %rcx,%rax
mulsd  (%rbx,%rcx,8),%xmm1
movsd  (%r14,%rax,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%r14,%rax,8)
lea    0x1(%rcx),%r13
not    %rcx
cmp    0xe8(%rsp),%rcx
je     1790 <main+0x5e0>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r15,%r10,8),%xmm1
mulsd  (%rbx,%r13,8),%xmm1
movsd  -0x8(%r12,%r13,8),%xmm2
subsd  %xmm1,%xmm2
movsd  (%r12,%r13,8),%xmm1
movsd  %xmm2,-0x8(%r12,%r13,8)
movsd  (%r15,%r10,8),%xmm2
mulsd  0x8(%rbx,%r13,8),%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%r12,%r13,8)
add    $0x2,%r13
cmp    %r13,%r9
jne    1810 <main+0x660>
jmp    1790 <main+0x5e0>
nopl   0x0(%rax)
mov    %rsi,%rcx
imul   %r9,%rcx
mov    0xd8(%rsp),%rax
lea    (%rax,%rcx,1),%rdx
lea    (%r14,%rdx,8),%rdx
add    %rbp,%rdx
add    0xe0(%rsp),%rcx
lea    (%r14,%rcx,8),%rcx
mov    0x18(%rsp),%rax
add    %rsi,%rax
lea    (%r15,%rax,8),%rax
cmp    %rax,%rdx
lea    (%r15,%r10,8),%rax
setb   %r14b
cmp    %rcx,%rax
setb   %al
cmp    0x90(%rsp),%rdx
setb   %dl
cmp    %rcx,0x28(%rsp)
setb   %r13b
mov    0x38(%rsp),%rcx
test   %al,%r14b
mov    0x88(%rsp),%r14
jne    17c3 <main+0x613>
mov    0x38(%rsp),%rcx
and    %r13b,%dl
jne    17c3 <main+0x613>
movsd  (%r15,%r10,8),%xmm1
unpcklpd %xmm1,%xmm1
xorpd  %xmm0,%xmm1
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movupd -0x10(%r8,%rcx,8),%xmm2
movupd (%r8,%rcx,8),%xmm3
movupd -0x10(%rdi,%rcx,8),%xmm4
movupd (%rdi,%rcx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,-0x10(%rdi,%rcx,8)
movupd %xmm3,(%rdi,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r11
jne    18f0 <main+0x740>
mov    0xb8(%rsp),%rcx
mov    0xc0(%rsp),%rax
cmp    %rax,0x10(%rsp)
je     1790 <main+0x5e0>
jmp    17c3 <main+0x613>
mov    0x20(%rsp),%rdx
mov    0x8(%rsp),%rbp
cmp    $0x3,%rcx
jae    16f0 <main+0x540>
jmp    1727 <main+0x577>
xor    %ebp,%ebp
xor    %edi,%edi
call   1090 <time@plt>
movsd  0x98(%rsp),%xmm1
call   1080 <difftime@plt>
lea    0x698(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0x6b2(%rip),%rdi
lea    0x6b8(%rip),%rsi
call   10b0 <fopen@plt>
test   %rax,%rax
je     19da <main+0x82a>
mov    %rax,%r14
mov    0x88(%rsp),%rdi
mov    $0x8,%esi
mov    0x44(%rsp),%edx
mov    %rax,%rcx
call   10d0 <fwrite@plt>
mov    %r14,%rdi
call   1060 <fclose@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
jmp    19eb <main+0x83b>
lea    0x673(%rip),%rdi
call   1040 <puts@plt>
mov    $0x1,%ebp
mov    %ebp,%eax
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [34 x i8] c"./xxx vector_size input_filename\0A\00"
@.str.1 = [11 x i8] c"input.data\00"
@.str.2 = [2 x i8] c"r\00"
@.str.3 = [18 x i8] c"fopen read error\0A\00"
@.str.4 = [42 x i8] c"Completed decomposition in %.3lf seconds\0A\00"
@.str.5 = [13 x i8] c"seqence.data\00"
@.str.6 = [2 x i8] c"w\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca double
%7 = alloca double
%8 = alloca double*
%9 = alloca double*
%10 = alloca double*
%11 = alloca i8*
%12 = alloca i32*
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%17 = load i32, i32* %4
%18 = icmp sle i32 %17, 1
br i1 %18, label %19, label %21
19: ; preds = %2
%20 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str, i64 0, i64 0))
store i32 1, i32* %3
br label %210
21: ; preds = %2
%22 = load i8**, i8*** %5
%23 = getelementptr inbounds i8*, i8** %22, i64 1
%24 = load i8*, i8** %23
%25 = call i32 @atoi(i8* %24)
store i32 %25, i32* %16
br label %26
26: ; preds = %21
%27 = call i32* @fopen(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
store i32* %27, i32** %12
%28 = icmp eq i32* %27, null
br i1 %28, label %29, label %31
29: ; preds = %26
%30 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.3, i64 0, i64 0))
store i32 1, i32* %3
br label %210
31: ; preds = %26
%32 = load i32, i32* %16
%33 = sext i32 %32 to i64
%34 = mul i64 8, %33
%35 = load i32, i32* %16
%36 = sext i32 %35 to i64
%37 = mul i64 %34, %36
%38 = trunc i64 %37 to i32
%39 = call i64 @malloc(i32 %38)
%40 = inttoptr i64 %39 to double*
store double* %40, double** %8
%41 = load double*, double** %8
%42 = load i32, i32* %16
%43 = load i32, i32* %16
%44 = mul nsw i32 %42, %43
%45 = load i32*, i32** %12
%46 = call i32 @fread(double* %41, i32 8, i32 %44, i32* %45)
%47 = load i32*, i32** %12
%48 = call i32 @fclose(i32* %47)
%49 = load i32, i32* %16
%50 = sext i32 %49 to i64
%51 = mul i64 8, %50
%52 = trunc i64 %51 to i32
%53 = call i64 @malloc(i32 %52)
%54 = inttoptr i64 %53 to double*
store double* %54, double** %9
%55 = load i32, i32* %16
%56 = sext i32 %55 to i64
%57 = mul i64 8, %56
%58 = trunc i64 %57 to i32
%59 = call i64 @malloc(i32 %58)
%60 = inttoptr i64 %59 to double*
store double* %60, double** %10
%61 = call double @time(i32 0)
store double %61, double* %6
store i32 0, i32* %15
br label %62
62: ; preds = %184, %31
%63 = load i32, i32* %15
%64 = load i32, i32* %16
%65 = sub nsw i32 %64, 1
%66 = icmp slt i32 %63, %65
br i1 %66, label %67, label %187
67: ; preds = %62
%68 = load i32, i32* %15
store i32 %68, i32* %13
br label %69
69: ; preds = %87, %67
%70 = load i32, i32* %13
%71 = load i32, i32* %16
%72 = icmp slt i32 %70, %71
br i1 %72, label %73, label %90
73: ; preds = %69
%74 = load double*, double** %8
%75 = load i32, i32* %13
%76 = load i32, i32* %16
%77 = mul nsw i32 %75, %76
%78 = load i32, i32* %15
%79 = add nsw i32 %77, %78
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds double, double* %74, i64 %80
%82 = load double, double* %81
%83 = load double*, double** %9
%84 = load i32, i32* %13
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds double, double* %83, i64 %85
store double %82, double* %86
br label %87
87: ; preds = %73
%88 = load i32, i32* %13
%89 = add nsw i32 %88, 1
store i32 %89, i32* %13
br label %69
90: ; preds = %69
%91 = load i32, i32* %15
%92 = add nsw i32 %91, 1
store i32 %92, i32* %13
br label %93
93: ; preds = %113, %90
%94 = load i32, i32* %13
%95 = load i32, i32* %16
%96 = icmp slt i32 %94, %95
br i1 %96, label %97, label %116
97: ; preds = %93
%98 = load double*, double** %9
%99 = load i32, i32* %15
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds double, double* %98, i64 %100
%102 = load double, double* %101
%103 = load double*, double** %8
%104 = load i32, i32* %15
%105 = load i32, i32* %16
%106 = mul nsw i32 %104, %105
%107 = load i32, i32* %13
%108 = add nsw i32 %106, %107
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds double, double* %103, i64 %109
%111 = load double, double* %110
%112 = fdiv double %111, %102
store double %112, double* %110
br label %113
113: ; preds = %97
%114 = load i32, i32* %13
%115 = add nsw i32 %114, 1
store i32 %115, i32* %13
br label %93
116: ; preds = %93
%117 = load i32, i32* %15
%118 = add nsw i32 %117, 1
store i32 %118, i32* %13
br label %119
119: ; preds = %137, %116
%120 = load i32, i32* %13
%121 = load i32, i32* %16
%122 = icmp slt i32 %120, %121
br i1 %122, label %123, label %140
123: ; preds = %119
%124 = load double*, double** %8
%125 = load i32, i32* %15
%126 = load i32, i32* %16
%127 = mul nsw i32 %125, %126
%128 = load i32, i32* %13
%129 = add nsw i32 %127, %128
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds double, double* %124, i64 %130
%132 = load double, double* %131
%133 = load double*, double** %10
%134 = load i32, i32* %13
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds double, double* %133, i64 %135
store double %132, double* %136
br label %137
137: ; preds = %123
%138 = load i32, i32* %13
%139 = add nsw i32 %138, 1
store i32 %139, i32* %13
br label %119
140: ; preds = %119
%141 = load i32, i32* %15
%142 = add nsw i32 %141, 1
store i32 %142, i32* %13
br label %143
143: ; preds = %180, %140
%144 = load i32, i32* %13
%145 = load i32, i32* %16
%146 = icmp slt i32 %144, %145
br i1 %146, label %147, label %183
147: ; preds = %143
%148 = load i32, i32* %15
%149 = add nsw i32 %148, 1
store i32 %149, i32* %14
br label %150
150: ; preds = %176, %147
%151 = load i32, i32* %14
%152 = load i32, i32* %16
%153 = icmp slt i32 %151, %152
br i1 %153, label %154, label %179
154: ; preds = %150
%155 = load double*, double** %9
%156 = load i32, i32* %13
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds double, double* %155, i64 %157
%159 = load double, double* %158
%160 = load double*, double** %10
%161 = load i32, i32* %14
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds double, double* %160, i64 %162
%164 = load double, double* %163
%165 = load double*, double** %8
%166 = load i32, i32* %13
%167 = load i32, i32* %16
%168 = mul nsw i32 %166, %167
%169 = load i32, i32* %14
%170 = add nsw i32 %168, %169
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds double, double* %165, i64 %171
%173 = load double, double* %172
%174 = fneg double %159
%175 = call double @llvm.fmuladd.f64(double %174, double %164, double %173)
store double %175, double* %172
br label %176
176: ; preds = %154
%177 = load i32, i32* %14
%178 = add nsw i32 %177, 1
store i32 %178, i32* %14
br label %150
179: ; preds = %150
br label %180
180: ; preds = %179
%181 = load i32, i32* %13
%182 = add nsw i32 %181, 1
store i32 %182, i32* %13
br label %143
183: ; preds = %143
br label %184
184: ; preds = %183
%185 = load i32, i32* %15
%186 = add nsw i32 %185, 1
store i32 %186, i32* %15
br label %62
187: ; preds = %62
%188 = call double @time(i32 0)
store double %188, double* %7
%189 = load double, double* %7
%190 = load double, double* %6
%191 = call i32 @difftime(double %189, double %190)
%192 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.4, i64 0, i64 0), i32 %191)
%193 = call i32* @fopen(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
store i32* %193, i32** %12
%194 = icmp eq i32* %193, null
br i1 %194, label %195, label %197
195: ; preds = %187
%196 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.3, i64 0, i64 0))
store i32 1, i32* %3
br label %210
197: ; preds = %187
%198 = load double*, double** %8
%199 = load i32, i32* %16
%200 = load i32, i32* %16
%201 = mul nsw i32 %199, %200
%202 = load i32*, i32** %12
%203 = call i32 @fwrite(double* %198, i32 8, i32 %201, i32* %202)
%204 = load i32*, i32** %12
%205 = call i32 @fclose(i32* %204)
%206 = load double*, double** %9
%207 = call i32 @free(double* %206)
%208 = load double*, double** %10
%209 = call i32 @free(double* %208)
store i32 0, i32* %3
br label %210
210: ; preds = %197, %195, %29, %19
%211 = load i32, i32* %3
ret i32 %211
}

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