#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*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fread(double *, int, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ fwrite(double *, int, int, int /*<<< orphan*/ *);
double *malloc(int);
int /*<<< orphan*/ print_usage();
int /*<<< orphan*/ printf(char *, ...);
scalar_t__ strcmp(char *, char *);
double utime();
int main(int argc, char *argv[]) {
  int i, j, k;
  int n;
  double *data;
  FILE *file;
  double time;
  n = 1024;
  if (argc > 1) {
    for (i = 1; i < argc;) {
      if (strcmp(argv[i], "-s") == 0) {
        n = atoi(argv[i + 1]);
        i += 2;
      } else {
        print_usage();
        return 0;
      }
    }
  }
  data = malloc(sizeof(double) * n * n);
  file = fopen("input.data", "r");
  if (file == NULL) {
    printf("can't not open the input.data file\n");
    return -1;
  }
  fread(data, sizeof(double), n * n, file);
  fclose(file);
  printf("sequence ASP processing...\n");
  time = -utime();
  for (k = 0; k < n; k++)
    for (i = 0; i < n; i++)
      for (j = 0; j < n; j++)
        if (data[i * n + j] > (data[i * n + k] + data[k * n + j]))
          data[i * n + j] = data[i * n + k] + data[k * n + j];
  time += utime();
  printf("Result:\n");
  printf("\tTIME\tVector_Size\n");
  printf("\t%f\t%d\n", time, n);
  file = fopen("sequence_output.data", "w");
  fwrite(data, sizeof(double), n * n, file);
  fclose(file);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x400,-0x20(%rbp)
cmpl   $0x1,-0x8(%rbp)
jle    1240 <main+0xa0>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    123b <main+0x9b>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xe13(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%rax
jne    1223 <main+0x83>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   10a0 <atoi@plt>
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
jmp    1236 <main+0x96>
mov    $0x0,%al
call   10c0 <print_usage@plt>
movl   $0x0,-0x4(%rbp)
jmp    146d <main+0x2cd>
jmp    11ce <main+0x2e>
jmp    1240 <main+0xa0>
movslq -0x20(%rbp),%rax
shl    $0x3,%rax
movslq -0x20(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x28(%rbp)
lea    0xda1(%rip),%rdi
lea    0xda5(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    1297 <main+0xf7>
lea    0xd8c(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    146d <main+0x2cd>
mov    -0x28(%rbp),%rdi
mov    -0x20(%rbp),%edx
imul   -0x20(%rbp),%edx
mov    -0x30(%rbp),%rcx
mov    $0x8,%esi
call   1040 <fread@plt>
mov    -0x30(%rbp),%rdi
call   1050 <fclose@plt>
lea    0xd74(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0x0,%al
call   1030 <utime@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    13ea <main+0x24a>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    13d7 <main+0x237>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    13c4 <main+0x224>
mov    -0x28(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
ucomisd %xmm1,%xmm0
jbe    13b1 <main+0x211>
mov    -0x28(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    13b6 <main+0x216>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1317 <main+0x177>
jmp    13c9 <main+0x229>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1304 <main+0x164>
jmp    13dc <main+0x23c>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12f1 <main+0x151>
mov    $0x0,%al
call   1030 <utime@plt>
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
lea    0xc4e(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xc49(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movsd  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%esi
lea    0xc46(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
lea    0xc40(%rip),%rdi
lea    0xc4e(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rdi
mov    -0x20(%rbp),%edx
imul   -0x20(%rbp),%edx
mov    -0x30(%rbp),%rcx
mov    $0x8,%esi
call   10b0 <fwrite@plt>
mov    -0x30(%rbp),%rdi
call   1050 <fclose@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    $0x400,%r12d
cmp    $0x2,%edi
jl     120b <main+0x5b>
mov    %rsi,%r15
mov    %edi,%ebp
mov    $0x1,%ebx
lea    0xe26(%rip),%r14
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rbx,8),%rdi
mov    %r14,%rsi
call   1080 <strcmp@plt>
test   %rax,%rax
jne    1578 <main+0x3c8>
add    $0x2,%rbx
cmp    %rbp,%rbx
jb     11e0 <main+0x30>
mov    -0x8(%r15,%rbx,8),%rdi
call   10b0 <atoi@plt>
mov    %eax,%r12d
mov    %r12d,%ebx
imul   %ebx,%ebx
lea    0x0(,%rbx,8),%edi
call   1090 <malloc@plt>
mov    %rax,%r14
lea    0xddc(%rip),%rdi
lea    0xde0(%rip),%rsi
call   10a0 <fopen@plt>
test   %rax,%rax
je     1565 <main+0x3b5>
mov    %rax,%r15
mov    %r14,%rdi
mov    $0x8,%esi
mov    %rbx,0x30(%rsp)
mov    %ebx,%edx
mov    %rax,%rcx
call   1050 <fread@plt>
mov    %r15,%rdi
call   1060 <fclose@plt>
lea    0xdca(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
call   1030 <utime@plt>
movsd  %xmm0,0x28(%rsp)
test   %r12d,%r12d
jle    14ec <main+0x33c>
mov    %r12d,%eax
mov    %eax,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x38(%rsp)
mov    %rax,%rcx
neg    %rcx
mov    %rcx,0x8(%rsp)
lea    0x0(,%rax,8),%r9
lea    0x10(%r14),%rdi
mov    %r9,%r11
and    $0xffffffffffffffe0,%r11
lea    0x8(%r14),%rbp
xor    %esi,%esi
mov    %r12d,0x4(%rsp)
mov    %r9,0x10(%rsp)
jmp    12d7 <main+0x127>
nopl   (%rax)
add    %r9,%rdi
add    %r9,%rbp
mov    0x20(%rsp),%rcx
mov    %rcx,%rsi
cmp    %rax,%rcx
je     14ec <main+0x33c>
lea    0x1(%rsi),%rcx
mov    %rcx,0x20(%rsp)
mov    %rsi,%rcx
imul   %rax,%rcx
lea    (%r14,%rcx,8),%rdx
mov    %rdx,0x50(%rsp)
mov    %rcx,0x40(%rsp)
add    %rax,%rcx
lea    (%r14,%rcx,8),%rcx
mov    %rcx,0x48(%rsp)
mov    %r14,%rbx
xor    %r15d,%r15d
mov    %rsi,0x18(%rsp)
jmp    131c <main+0x16c>
xchg   %ax,%ax
add    $0x1,%r15
add    %r9,%rbx
cmp    %rax,%r15
je     12c0 <main+0x110>
mov    %r15,%r8
imul   %rax,%r8
lea    (%r8,%rsi,1),%r13
cmp    $0x4,%r12d
jae    13d0 <main+0x220>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%al
je     136a <main+0x1ba>
add    %rdx,%r8
movsd  (%r14,%r8,8),%xmm1
movsd  (%r14,%r13,8),%xmm0
mov    0x40(%rsp),%rcx
add    %rdx,%rcx
addsd  (%r14,%rcx,8),%xmm0
ucomisd %xmm0,%xmm1
jbe    1363 <main+0x1b3>
movsd  %xmm0,(%r14,%r8,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x8(%rsp),%rdx
jne    1389 <main+0x1d9>
jmp    1310 <main+0x160>
cs nopw 0x0(%rax,%rax,1)
add    $0x2,%rcx
cmp    %rcx,%rax
je     1310 <main+0x160>
movsd  (%rbx,%rcx,8),%xmm1
movsd  (%r14,%r13,8),%xmm0
addsd  -0x8(%rbp,%rcx,8),%xmm0
ucomisd %xmm0,%xmm1
jbe    13a5 <main+0x1f5>
movsd  %xmm0,(%rbx,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm1
movsd  (%r14,%r13,8),%xmm0
addsd  0x0(%rbp,%rcx,8),%xmm0
ucomisd %xmm0,%xmm1
jbe    1380 <main+0x1d0>
movsd  %xmm0,0x8(%rbx,%rcx,8)
jmp    1380 <main+0x1d0>
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%r8,%rax,1),%rcx
lea    (%r14,%r8,8),%rdx
lea    (%r14,%rcx,8),%rsi
mov    0x20(%rsp),%rcx
add    %r8,%rcx
lea    (%r14,%rcx,8),%rcx
lea    (%r14,%r13,8),%r10
cmp    %rcx,%rdx
setb   %r9b
cmp    %rsi,%r10
setb   %r12b
cmp    0x48(%rsp),%rdx
setb   %cl
cmp    %rsi,0x50(%rsp)
setb   %r10b
test   %r12b,%r9b
jne    14d6 <main+0x326>
mov    $0x0,%edx
and    %r10b,%cl
mov    0x4(%rsp),%r12d
mov    0x10(%rsp),%r9
mov    0x18(%rsp),%rsi
jne    1333 <main+0x183>
movsd  (%r14,%r13,8),%xmm0
unpcklpd %xmm0,%xmm0
xor    %r10d,%r10d
jmp    1449 <main+0x299>
add    $0x20,%r10
cmp    %r10,%r11
je     14c0 <main+0x310>
movupd (%rbx,%r10,1),%xmm3
movupd -0x10(%rdi,%r10,1),%xmm2
movupd (%rdi,%r10,1),%xmm1
addpd  %xmm0,%xmm2
ucomisd %xmm2,%xmm3
jbe    146c <main+0x2bc>
movlpd %xmm2,(%rbx,%r10,1)
movapd %xmm2,%xmm4
cmpltpd %xmm3,%xmm4
pextrw $0x4,%xmm4,%ecx
test   $0x1,%cl
je     1486 <main+0x2d6>
movhpd %xmm2,0x8(%rbx,%r10,1)
movupd 0x10(%rbx,%r10,1),%xmm2
addpd  %xmm0,%xmm1
ucomisd %xmm1,%xmm2
jbe    149e <main+0x2ee>
movlpd %xmm1,0x10(%rbx,%r10,1)
movapd %xmm1,%xmm3
cmpltpd %xmm2,%xmm3
pextrw $0x4,%xmm3,%ecx
test   $0x1,%cl
je     1440 <main+0x290>
movhpd %xmm1,0x18(%rbx,%r10,1)
jmp    1440 <main+0x290>
nopw   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rax,%rcx
je     1310 <main+0x160>
jmp    1333 <main+0x183>
xor    %edx,%edx
mov    0x4(%rsp),%r12d
mov    0x10(%rsp),%r9
mov    0x18(%rsp),%rsi
jmp    1333 <main+0x183>
xor    %eax,%eax
call   1030 <utime@plt>
subsd  0x28(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
lea    0xb44(%rip),%rdi
call   1040 <puts@plt>
lea    0xb40(%rip),%rdi
call   1040 <puts@plt>
lea    0xaf2(%rip),%rdi
movsd  0x8(%rsp),%xmm0
mov    %r12d,%esi
mov    $0x1,%al
call   1070 <printf@plt>
lea    0xae3(%rip),%rdi
lea    0xaf1(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,%rbp
mov    %r14,%rdi
mov    $0x8,%esi
mov    0x30(%rsp),%rdx
mov    %rax,%rcx
call   10c0 <fwrite@plt>
mov    %rbp,%rdi
call   1060 <fclose@plt>
xor    %ebx,%ebx
jmp    1581 <main+0x3d1>
lea    0xaf8(%rip),%rdi
call   1040 <puts@plt>
mov    $0xffffffff,%ebx
jmp    1581 <main+0x3d1>
xor    %ebx,%ebx
xor    %eax,%eax
call   10d0 <print_usage@plt>
mov    %ebx,%eax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c"-s\00"
@.str.1 = [11 x i8] c"input.data\00"
@.str.2 = [2 x i8] c"r\00"
@.str.3 = [36 x i8] c"can't not open the input.data file\0A\00"
@.str.4 = [28 x i8] c"sequence ASP processing...\0A\00"
@.str.5 = [9 x i8] c"Result:\0A\00"
@.str.6 = [19 x i8] c"\09TIME\09Vector_Size\0A\00"
@.str.7 = [8 x i8] c"\09%f\09%d\0A\00"
@.str.8 = [21 x i8] c"sequence_output.data\00"
@.str.9 = [2 x i8] c"w\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca double*
%11 = alloca i32*
%12 = alloca double
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i32 1024, i32* %9
%13 = load i32, i32* %4
%14 = icmp sgt i32 %13, 1
br i1 %14, label %15, label %42
15: ; preds = %2
store i32 1, i32* %6
br label %16
16: ; preds = %40, %15
%17 = load i32, i32* %6
%18 = load i32, i32* %4
%19 = icmp slt i32 %17, %18
br i1 %19, label %20, label %41
20: ; preds = %16
%21 = load i8**, i8*** %5
%22 = load i32, i32* %6
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds i8*, i8** %21, i64 %23
%25 = load i8*, i8** %24
%26 = call i64 @strcmp(i8* %25, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
%27 = icmp eq i64 %26, 0
br i1 %27, label %28, label %38
28: ; preds = %20
%29 = load i8**, i8*** %5
%30 = load i32, i32* %6
%31 = add nsw i32 %30, 1
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds i8*, i8** %29, i64 %32
%34 = load i8*, i8** %33
%35 = call i32 @atoi(i8* %34)
store i32 %35, i32* %9
%36 = load i32, i32* %6
%37 = add nsw i32 %36, 2
store i32 %37, i32* %6
br label %40
38: ; preds = %20
%39 = call i32 (...) @print_usage()
store i32 0, i32* %3
br label %170
40: ; preds = %28
br label %16
41: ; preds = %16
br label %42
42: ; preds = %41, %2
%43 = load i32, i32* %9
%44 = sext i32 %43 to i64
%45 = mul i64 8, %44
%46 = load i32, i32* %9
%47 = sext i32 %46 to i64
%48 = mul i64 %45, %47
%49 = trunc i64 %48 to i32
%50 = call double* @malloc(i32 %49)
store double* %50, double** %10
%51 = 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* %51, i32** %11
%52 = load i32*, i32** %11
%53 = icmp eq i32* %52, null
br i1 %53, label %54, label %56
54: ; preds = %42
%55 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.3, i64 0, i64 0))
store i32 -1, i32* %3
br label %170
56: ; preds = %42
%57 = load double*, double** %10
%58 = load i32, i32* %9
%59 = load i32, i32* %9
%60 = mul nsw i32 %58, %59
%61 = load i32*, i32** %11
%62 = call i32 @fread(double* %57, i32 8, i32 %60, i32* %61)
%63 = load i32*, i32** %11
%64 = call i32 @fclose(i32* %63)
%65 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.4, i64 0, i64 0))
%66 = call double (...) @utime()
%67 = fneg double %66
store double %67, double* %12
store i32 0, i32* %8
br label %68
68: ; preds = %149, %56
%69 = load i32, i32* %8
%70 = load i32, i32* %9
%71 = icmp slt i32 %69, %70
br i1 %71, label %72, label %152
72: ; preds = %68
store i32 0, i32* %6
br label %73
73: ; preds = %145, %72
%74 = load i32, i32* %6
%75 = load i32, i32* %9
%76 = icmp slt i32 %74, %75
br i1 %76, label %77, label %148
77: ; preds = %73
store i32 0, i32* %7
br label %78
78: ; preds = %141, %77
%79 = load i32, i32* %7
%80 = load i32, i32* %9
%81 = icmp slt i32 %79, %80
br i1 %81, label %82, label %144
82: ; preds = %78
%83 = load double*, double** %10
%84 = load i32, i32* %6
%85 = load i32, i32* %9
%86 = mul nsw i32 %84, %85
%87 = load i32, i32* %7
%88 = add nsw i32 %86, %87
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds double, double* %83, i64 %89
%91 = load double, double* %90
%92 = load double*, double** %10
%93 = load i32, i32* %6
%94 = load i32, i32* %9
%95 = mul nsw i32 %93, %94
%96 = load i32, i32* %8
%97 = add nsw i32 %95, %96
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds double, double* %92, i64 %98
%100 = load double, double* %99
%101 = load double*, double** %10
%102 = load i32, i32* %8
%103 = load i32, i32* %9
%104 = mul nsw i32 %102, %103
%105 = load i32, i32* %7
%106 = add nsw i32 %104, %105
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds double, double* %101, i64 %107
%109 = load double, double* %108
%110 = fadd double %100, %109
%111 = fcmp ogt double %91, %110
br i1 %111, label %112, label %140
112: ; preds = %82
%113 = load double*, double** %10
%114 = load i32, i32* %6
%115 = load i32, i32* %9
%116 = mul nsw i32 %114, %115
%117 = load i32, i32* %8
%118 = add nsw i32 %116, %117
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds double, double* %113, i64 %119
%121 = load double, double* %120
%122 = load double*, double** %10
%123 = load i32, i32* %8
%124 = load i32, i32* %9
%125 = mul nsw i32 %123, %124
%126 = load i32, i32* %7
%127 = add nsw i32 %125, %126
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds double, double* %122, i64 %128
%130 = load double, double* %129
%131 = fadd double %121, %130
%132 = load double*, double** %10
%133 = load i32, i32* %6
%134 = load i32, i32* %9
%135 = mul nsw i32 %133, %134
%136 = load i32, i32* %7
%137 = add nsw i32 %135, %136
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds double, double* %132, i64 %138
store double %131, double* %139
br label %140
140: ; preds = %112, %82
br label %141
141: ; preds = %140
%142 = load i32, i32* %7
%143 = add nsw i32 %142, 1
store i32 %143, i32* %7
br label %78
144: ; preds = %78
br label %145
145: ; preds = %144
%146 = load i32, i32* %6
%147 = add nsw i32 %146, 1
store i32 %147, i32* %6
br label %73
148: ; preds = %73
br label %149
149: ; preds = %148
%150 = load i32, i32* %8
%151 = add nsw i32 %150, 1
store i32 %151, i32* %8
br label %68
152: ; preds = %68
%153 = call double (...) @utime()
%154 = load double, double* %12
%155 = fadd double %154, %153
store double %155, double* %12
%156 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0))
%157 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.6, i64 0, i64 0))
%158 = load double, double* %12
%159 = load i32, i32* %9
%160 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.7, i64 0, i64 0), double %158, i32 %159)
%161 = call i32* @fopen(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0))
store i32* %161, i32** %11
%162 = load double*, double** %10
%163 = load i32, i32* %9
%164 = load i32, i32* %9
%165 = mul nsw i32 %163, %164
%166 = load i32*, i32** %11
%167 = call i32 @fwrite(double* %162, i32 8, i32 %165, i32* %166)
%168 = load i32*, i32** %11
%169 = call i32 @fclose(i32* %168)
store i32 0, i32* %3
br label %170
170: ; preds = %152, %54, %38
%171 = load i32, i32* %3
ret i32 %171
}

LLVM IR (-O2):
@.str = [3 x i8] c"-s\00"
@.str.1 = [11 x i8] c"input.data\00"
@.str.2 = [2 x i8] c"r\00"
@.str.7 = [8 x i8] c"\09%f\09%d\0A\00"
@.str.8 = [21 x i8] c"sequence_output.data\00"
@.str.9 = [2 x i8] c"w\00"
@str = [27 x i8] c"sequence ASP processing...\00"
@str.10 = [8 x i8] c"Result:\00"
@str.11 = [18 x i8] c"\09TIME\09Vector_Size\00"
@str.12 = [35 x i8] c"can't not open the input.data file\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = icmp sgt i32 %0, 1
br i1 %3, label %4, label %22
4: ; preds = %2
%5 = zext i32 %0 to i64
br label %6
6: ; preds = %4, %12
%7 = phi i64 [ 1, %4 ], [ %13, %12 ]
%8 = getelementptr inbounds i8*, i8** %1, i64 %7
%9 = load i8*, i8** %8
%10 = tail call i64 @strcmp(i8* %9, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
%11 = icmp eq i64 %10, 0
br i1 %11, label %12, label %15
12: ; preds = %6
%13 = add nuw nsw i64 %7, 2
%14 = icmp ult i64 %13, %5
br i1 %14, label %6, label %17
15: ; preds = %6
%16 = tail call i32 (...) @print_usage()
br label %192
17: ; preds = %12
%18 = add nuw nsw i64 %7, 1
%19 = getelementptr inbounds i8*, i8** %1, i64 %18
%20 = load i8*, i8** %19
%21 = tail call i32 @atoi(i8* %20)
br label %22
22: ; preds = %17, %2
%23 = phi i32 [ 1024, %2 ], [ %21, %17 ]
%24 = shl i32 %23, 3
%25 = mul i32 %24, %23
%26 = tail call double* @malloc(i32 %25)
%27 = 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))
%28 = icmp eq i32* %27, null
br i1 %28, label %29, label %31
29: ; preds = %22
%30 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([35 x i8], [35 x i8]* @str.12, i64 0, i64 0))
br label %192
31: ; preds = %22
%32 = mul nsw i32 %23, %23
%33 = tail call i32 @fread(double* %26, i32 8, i32 %32, i32* %27)
%34 = tail call i32 @fclose(i32* %27)
%35 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str, i64 0, i64 0))
%36 = tail call double (...) @utime()
%37 = icmp sgt i32 %23, 0
br i1 %37, label %38, label %183
38: ; preds = %31
%39 = zext i32 %23 to i64
%40 = zext i32 %23 to i64
%41 = icmp ult i32 %23, 4
%42 = and i64 %40, 4294967292
%43 = icmp eq i64 %42, %40
%44 = and i64 %40, 1
%45 = icmp eq i64 %44, 0
%46 = sub nsw i64 0, %40
br label %47
47: ; preds = %180, %38
%48 = phi i64 [ 0, %38 ], [ %181, %180 ]
%49 = add nuw i64 %48, 1
%50 = mul i64 %48, %40
%51 = getelementptr double, double* %26, i64 %50
%52 = add i64 %50, %40
%53 = getelementptr double, double* %26, i64 %52
%54 = mul nsw i64 %48, %39
br label %55
55: ; preds = %177, %47
%56 = phi i64 [ 0, %47 ], [ %178, %177 ]
%57 = mul i64 %56, %40
%58 = getelementptr double, double* %26, i64 %57
%59 = add i64 %57, %40
%60 = getelementptr double, double* %26, i64 %59
%61 = mul nsw i64 %56, %39
%62 = add nuw nsw i64 %61, %48
%63 = getelementptr inbounds double, double* %26, i64 %62
br i1 %41, label %131, label %64
64: ; preds = %55
%65 = add i64 %49, %57
%66 = getelementptr double, double* %26, i64 %65
%67 = add i64 %48, %57
%68 = getelementptr double, double* %26, i64 %67
%69 = icmp ult double* %58, %66
%70 = icmp ult double* %68, %60
%71 = and i1 %69, %70
%72 = icmp ult double* %58, %53
%73 = icmp ult double* %51, %60
%74 = and i1 %72, %73
%75 = or i1 %71, %74
br i1 %75, label %131, label %76
76: ; preds = %64
%77 = load double, double* %63
%78 = insertelement <2 x double> poison, double %77, i64 0
%79 = shufflevector <2 x double> %78, <2 x double> poison, <2 x i32> zeroinitializer
%80 = insertelement <2 x double> poison, double %77, i64 0
%81 = shufflevector <2 x double> %80, <2 x double> poison, <2 x i32> zeroinitializer
br label %82
82: ; preds = %127, %76
%83 = phi i64 [ 0, %76 ], [ %128, %127 ]
%84 = or i64 %83, 2
%85 = add nuw nsw i64 %83, %61
%86 = add nuw nsw i64 %84, %61
%87 = getelementptr inbounds double, double* %26, i64 %85
%88 = bitcast double* %87 to <2 x double>*
%89 = load <2 x double>, <2 x double>* %88
%90 = getelementptr inbounds double, double* %87, i64 2
%91 = bitcast double* %90 to <2 x double>*
%92 = load <2 x double>, <2 x double>* %91
%93 = add nuw nsw i64 %83, %54
%94 = getelementptr inbounds double, double* %26, i64 %93
%95 = bitcast double* %94 to <2 x double>*
%96 = load <2 x double>, <2 x double>* %95
%97 = getelementptr inbounds double, double* %94, i64 2
%98 = bitcast double* %97 to <2 x double>*
%99 = load <2 x double>, <2 x double>* %98
%100 = fadd <2 x double> %79, %96
%101 = fadd <2 x double> %81, %99
%102 = fcmp ogt <2 x double> %89, %100
%103 = fcmp ogt <2 x double> %92, %101
%104 = extractelement <2 x i1> %102, i64 0
br i1 %104, label %105, label %108
105: ; preds = %82
%106 = getelementptr inbounds double, double* %26, i64 %85
%107 = extractelement <2 x double> %100, i64 0
store double %107, double* %106
br label %108
108: ; preds = %105, %82
%109 = extractelement <2 x i1> %102, i64 1
br i1 %109, label %110, label %115
110: ; preds = %108
%111 = or i64 %83, 1
%112 = add nuw nsw i64 %111, %61
%113 = getelementptr inbounds double, double* %26, i64 %112
%114 = extractelement <2 x double> %100, i64 1
store double %114, double* %113
br label %115
115: ; preds = %110, %108
%116 = extractelement <2 x i1> %103, i64 0
br i1 %116, label %117, label %120
117: ; preds = %115
%118 = getelementptr inbounds double, double* %26, i64 %86
%119 = extractelement <2 x double> %101, i64 0
store double %119, double* %118
br label %120
120: ; preds = %117, %115
%121 = extractelement <2 x i1> %103, i64 1
br i1 %121, label %122, label %127
122: ; preds = %120
%123 = or i64 %83, 3
%124 = add nuw nsw i64 %123, %61
%125 = getelementptr inbounds double, double* %26, i64 %124
%126 = extractelement <2 x double> %101, i64 1
store double %126, double* %125
br label %127
127: ; preds = %122, %120
%128 = add nuw i64 %83, 4
%129 = icmp eq i64 %128, %42
br i1 %129, label %130, label %82
130: ; preds = %127
br i1 %43, label %177, label %131
131: ; preds = %64, %55, %130
%132 = phi i64 [ 0, %64 ], [ 0, %55 ], [ %42, %130 ]
%133 = xor i64 %132, -1
br i1 %45, label %147, label %134
134: ; preds = %131
%135 = add nuw nsw i64 %132, %61
%136 = getelementptr inbounds double, double* %26, i64 %135
%137 = load double, double* %136
%138 = load double, double* %63
%139 = add nuw nsw i64 %132, %54
%140 = getelementptr inbounds double, double* %26, i64 %139
%141 = load double, double* %140
%142 = fadd double %138, %141
%143 = fcmp ogt double %137, %142
br i1 %143, label %144, label %145
144: ; preds = %134
store double %142, double* %136
br label %145
145: ; preds = %144, %134
%146 = or i64 %132, 1
br label %147
147: ; preds = %145, %131
%148 = phi i64 [ %132, %131 ], [ %146, %145 ]
%149 = icmp eq i64 %133, %46
br i1 %149, label %177, label %150
150: ; preds = %147, %174
%151 = phi i64 [ %175, %174 ], [ %148, %147 ]
%152 = add nuw nsw i64 %151, %61
%153 = getelementptr inbounds double, double* %26, i64 %152
%154 = load double, double* %153
%155 = load double, double* %63
%156 = add nuw nsw i64 %151, %54
%157 = getelementptr inbounds double, double* %26, i64 %156
%158 = load double, double* %157
%159 = fadd double %155, %158
%160 = fcmp ogt double %154, %159
br i1 %160, label %161, label %162
161: ; preds = %150
store double %159, double* %153
br label %162
162: ; preds = %150, %161
%163 = add nuw nsw i64 %151, 1
%164 = add nuw nsw i64 %163, %61
%165 = getelementptr inbounds double, double* %26, i64 %164
%166 = load double, double* %165
%167 = load double, double* %63
%168 = add nuw nsw i64 %163, %54
%169 = getelementptr inbounds double, double* %26, i64 %168
%170 = load double, double* %169
%171 = fadd double %167, %170
%172 = fcmp ogt double %166, %171
br i1 %172, label %173, label %174
173: ; preds = %162
store double %171, double* %165
br label %174
174: ; preds = %173, %162
%175 = add nuw nsw i64 %151, 2
%176 = icmp eq i64 %175, %40
br i1 %176, label %177, label %150
177: ; preds = %147, %174, %130
%178 = add nuw nsw i64 %56, 1
%179 = icmp eq i64 %178, %40
br i1 %179, label %180, label %55
180: ; preds = %177
%181 = add nuw nsw i64 %48, 1
%182 = icmp eq i64 %181, %40
br i1 %182, label %183, label %47
183: ; preds = %180, %31
%184 = tail call double (...) @utime()
%185 = fsub double %184, %36
%186 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @str.10, i64 0, i64 0))
%187 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str.11, i64 0, i64 0))
%188 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.7, i64 0, i64 0), double %185, i32 %23)
%189 = tail call i32* @fopen(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0))
%190 = tail call i32 @fwrite(double* %26, i32 8, i32 %32, i32* %189)
%191 = tail call i32 @fclose(i32* %189)
br label %192
192: ; preds = %183, %29, %15
%193 = phi i32 [ 0, %15 ], [ -1, %29 ], [ 0, %183 ]
ret i32 %193
}