#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*/ EXIT_FAILURE;
int EXIT_SUCCESS;
int atoi(char *);
int /*<<< orphan*/ d_Ax(int, int, double *, double **, double *);
int /*<<< orphan*/ d_axpy(int, double *, double, double *, double *);
double **dmatrix(int, int);
double *dvector(int);
int /*<<< orphan*/ exit(int /*<<< orphan*/);
int /*<<< orphan*/ fflush(int /*<<< orphan*/);
double norm2(int, double *);
int /*<<< orphan*/ print_timing(char *, double *, int, double, int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ rand_matrix(int, double **);
int /*<<< orphan*/ rand_vector(int, double *);
int /*<<< orphan*/ solve(int, double *, double **, double *);
int /*<<< orphan*/ srand(int /*<<< orphan*/);
int /*<<< orphan*/ stdout;
double stoptime();
int /*<<< orphan*/ time(int /*<<< orphan*/ *);
int main(int argc, char **argv) {
  int n;
  double **A;
  double *b;
  double *x, *x_sol, *x_err;
  double norm = 0.0;
  double t[5];
  int csvout;
  t[4] = stoptime();
  if (argc < 2) {
    printf("usage: %s <matrix order> [csvout]\n", argv[0]);
    exit(EXIT_FAILURE);
  }
  if (argc == 2) {
    csvout = 0;
  } else {
    csvout = 1;
  }
  n = atoi(argv[1]);
  if (n <= 0)
    n = 1;
  t[0] = stoptime();
  A = dmatrix(n, n);
  b = dvector(n);
  x = dvector(n);
  x_sol = dvector(n);
  x_err = dvector(n);
  t[0] = stoptime() - t[0];
  t[1] = stoptime();
  srand(time(NULL));
  rand_matrix(n, A);
  rand_vector(n, x_sol);
  t[1] = stoptime() - t[1];
  t[2] = stoptime();
  d_Ax(n, n, b, A, x_sol);
  t[2] = stoptime() - t[2];
  if (!csvout) {
    printf("solving ... ");
    fflush(stdout);
  }
  t[3] = stoptime();
  solve(n, x, A, b);
  t[3] = stoptime() - t[3];
  if (!csvout) {
    printf("finished\n");
    fflush(stdout);
  }
  d_axpy(n, x_err, -1.0, x_sol, x);
  norm = norm2(n, x_err);
  if (!csvout) {
    printf("The norm of the error is %e\n", norm);
  }
  t[4] = stoptime() - t[4];
  print_timing(argv[0], t, n, norm, csvout);
  return EXIT_SUCCESS;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    $0x0,%al
call   10e0 <stoptime@plt>
movsd  %xmm0,-0x50(%rbp)
cmpl   $0x2,-0x8(%rbp)
jge    125a <main+0x5a>
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
lea    0xdc3(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    0x2d8d(%rip),%rax
mov    (%rax),%edi
call   1100 <exit@plt>
cmpl   $0x2,-0x8(%rbp)
jne    1270 <main+0x70>
movl   $0x0,-0x74(%rbp)
jmp    1277 <main+0x77>
movl   $0x1,-0x74(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   10f0 <atoi@plt>
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jg     1298 <main+0x98>
movl   $0x1,-0x14(%rbp)
mov    $0x0,%al
call   10e0 <stoptime@plt>
movsd  %xmm0,-0x70(%rbp)
mov    -0x14(%rbp),%edi
mov    -0x14(%rbp),%esi
call   1080 <dmatrix@plt>
mov    %rax,-0x20(%rbp)
mov    -0x14(%rbp),%edi
call   10c0 <dvector@plt>
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%edi
call   10c0 <dvector@plt>
mov    %rax,-0x30(%rbp)
mov    -0x14(%rbp),%edi
call   10c0 <dvector@plt>
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%edi
call   10c0 <dvector@plt>
mov    %rax,-0x40(%rbp)
mov    $0x0,%al
call   10e0 <stoptime@plt>
subsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    $0x0,%al
call   10e0 <stoptime@plt>
movsd  %xmm0,-0x68(%rbp)
xor    %eax,%eax
mov    %eax,%edi
call   10a0 <time@plt>
mov    %eax,%edi
call   1070 <srand@plt>
mov    -0x14(%rbp),%edi
mov    -0x20(%rbp),%rsi
call   1120 <rand_matrix@plt>
mov    -0x14(%rbp),%edi
mov    -0x38(%rbp),%rsi
call   10d0 <rand_vector@plt>
mov    $0x0,%al
call   10e0 <stoptime@plt>
subsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    $0x0,%al
call   10e0 <stoptime@plt>
movsd  %xmm0,-0x60(%rbp)
mov    -0x14(%rbp),%edi
mov    -0x14(%rbp),%esi
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x38(%rbp),%r8
call   1050 <d_Ax@plt>
mov    $0x0,%al
call   10e0 <stoptime@plt>
subsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
cmpl   $0x0,-0x74(%rbp)
jne    1393 <main+0x193>
lea    0xcad(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    0x2c4c(%rip),%rax
mov    (%rax),%edi
call   10b0 <fflush@plt>
mov    $0x0,%al
call   10e0 <stoptime@plt>
movsd  %xmm0,-0x58(%rbp)
mov    -0x14(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
call   1030 <solve@plt>
mov    $0x0,%al
call   10e0 <stoptime@plt>
subsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
cmpl   $0x0,-0x74(%rbp)
jne    13ea <main+0x1ea>
lea    0xc63(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    0x2bf5(%rip),%rax
mov    (%rax),%edi
call   10b0 <fflush@plt>
mov    -0x14(%rbp),%edi
mov    -0x40(%rbp),%rsi
mov    -0x38(%rbp),%rdx
mov    -0x30(%rbp),%rcx
movsd  0xbff(%rip),%xmm0
call   1090 <d_axpy@plt>
mov    -0x14(%rbp),%edi
mov    -0x40(%rbp),%rsi
call   1040 <norm2@plt>
movsd  %xmm0,-0x48(%rbp)
cmpl   $0x0,-0x74(%rbp)
jne    1434 <main+0x234>
movsd  -0x48(%rbp),%xmm0
lea    0xc15(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0x0,%al
call   10e0 <stoptime@plt>
subsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
lea    -0x70(%rbp),%rsi
mov    -0x14(%rbp),%edx
movsd  -0x48(%rbp),%xmm0
mov    -0x74(%rbp),%ecx
call   1110 <print_timing@plt>
mov    0x2b69(%rip),%rax
mov    (%rax),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %rsi,%rbx
mov    %edi,%r13d
xor    %eax,%eax
call   10f0 <stoptime@plt>
movsd  %xmm0,0x28(%rsp)
movsd  %xmm0,0x50(%rsp)
cmp    $0x1,%r13d
jle    146e <main+0x25e>
mov    %rbx,0x20(%rsp)
mov    0x8(%rbx),%rdi
call   1100 <atoi@plt>
test   %eax,%eax
mov    $0x1,%ebx
cmovg  %eax,%ebx
xor    %eax,%eax
call   10f0 <stoptime@plt>
movapd %xmm0,0x10(%rsp)
mov    %ebx,%edi
mov    %ebx,%esi
call   1090 <dmatrix@plt>
mov    %rax,%r14
mov    %ebx,%edi
call   10d0 <dvector@plt>
mov    %rax,%r15
mov    %ebx,%edi
call   10d0 <dvector@plt>
mov    %rax,0x8(%rsp)
mov    %ebx,%edi
call   10d0 <dvector@plt>
mov    %rax,%rbp
mov    %ebx,%edi
call   10d0 <dvector@plt>
mov    %rax,%r12
xor    %eax,%eax
call   10f0 <stoptime@plt>
movapd %xmm0,0x70(%rsp)
xor    %eax,%eax
call   10f0 <stoptime@plt>
movapd %xmm0,0x60(%rsp)
xor    %edi,%edi
call   10b0 <time@plt>
mov    %eax,%edi
call   1080 <srand@plt>
mov    %ebx,%edi
mov    %r14,%rsi
call   1130 <rand_matrix@plt>
mov    %ebx,%edi
mov    %rbp,%rsi
call   10e0 <rand_vector@plt>
xor    %eax,%eax
call   10f0 <stoptime@plt>
movapd 0x70(%rsp),%xmm1
unpcklpd %xmm0,%xmm1
movapd 0x10(%rsp),%xmm0
unpcklpd 0x60(%rsp),%xmm0
subpd  %xmm0,%xmm1
movapd %xmm1,0x30(%rsp)
xor    %eax,%eax
call   10f0 <stoptime@plt>
movsd  %xmm0,0x10(%rsp)
mov    %ebx,%edi
mov    %ebx,%esi
mov    %r15,%rdx
mov    %r14,%rcx
mov    %rbp,%r8
call   1060 <d_Ax@plt>
xor    %eax,%eax
call   10f0 <stoptime@plt>
subsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x40(%rsp)
cmp    $0x2,%r13d
jne    13a4 <main+0x194>
lea    0xcea(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
mov    0x2c89(%rip),%rax
mov    (%rax),%edi
call   10c0 <fflush@plt>
xor    %eax,%eax
call   10f0 <stoptime@plt>
movsd  %xmm0,0x10(%rsp)
mov    %ebx,%edi
mov    0x8(%rsp),%rsi
mov    %r14,%rdx
mov    %r15,%rcx
call   1030 <solve@plt>
xor    %eax,%eax
call   10f0 <stoptime@plt>
subsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x48(%rsp)
lea    0xcc6(%rip),%rdi
call   1040 <puts@plt>
mov    0x2c3d(%rip),%rax
mov    (%rax),%edi
call   10c0 <fflush@plt>
jmp    13d6 <main+0x1c6>
xor    %eax,%eax
call   10f0 <stoptime@plt>
movsd  %xmm0,0x10(%rsp)
mov    %ebx,%edi
mov    0x8(%rsp),%rsi
mov    %r14,%rdx
mov    %r15,%rcx
call   1030 <solve@plt>
xor    %eax,%eax
call   10f0 <stoptime@plt>
subsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x48(%rsp)
movsd  0xc22(%rip),%xmm0
mov    %ebx,%edi
mov    %r12,%rsi
mov    %rbp,%rdx
mov    0x8(%rsp),%rcx
call   10a0 <d_axpy@plt>
mov    %ebx,%edi
mov    %r12,%rsi
call   1050 <norm2@plt>
movsd  %xmm0,0x8(%rsp)
cmp    $0x2,%r13d
jne    141a <main+0x20a>
lea    0xc2b(%rip),%rdi
movsd  0x8(%rsp),%xmm0
mov    $0x1,%al
call   1070 <printf@plt>
xor    %ebp,%ebp
cmp    $0x2,%r13d
setne  %bpl
xor    %eax,%eax
call   10f0 <stoptime@plt>
subsd  0x28(%rsp),%xmm0
movsd  %xmm0,0x50(%rsp)
mov    0x20(%rsp),%rax
mov    (%rax),%rdi
lea    0x30(%rsp),%rsi
mov    %ebx,%edx
movsd  0x8(%rsp),%xmm0
mov    %ebp,%ecx
call   1120 <print_timing@plt>
mov    0x2b76(%rip),%rax
mov    (%rax),%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    (%rbx),%rsi
lea    0xb90(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
mov    0x2b5a(%rip),%rax
mov    (%rax),%edi
call   1110 <exit@plt>

LLVM IR (-O0):
@.str = [35 x i8] c"usage: %s <matrix order> [csvout]\0A\00"
@EXIT_FAILURE = global i32 0
@.str.1 = [13 x i8] c"solving ... \00"
@stdout = global i32 0
@.str.2 = [10 x i8] c"finished\0A\00"
@.str.3 = [29 x i8] c"The norm of the error is %e\0A\00"
@EXIT_SUCCESS = global i32 0
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca double**
%8 = alloca double*
%9 = alloca double*
%10 = alloca double*
%11 = alloca double*
%12 = alloca double
%13 = alloca [5 x double]
%14 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store double 0.000000e+00, double* %12
%15 = call double (...) @stoptime()
%16 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 4
store double %15, double* %16
%17 = load i32, i32* %4
%18 = icmp slt i32 %17, 2
br i1 %18, label %19, label %26
19: ; preds = %2
%20 = load i8**, i8*** %5
%21 = getelementptr inbounds i8*, i8** %20, i64 0
%22 = load i8*, i8** %21
%23 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str, i64 0, i64 0), i8* %22)
%24 = load i32, i32* @EXIT_FAILURE
%25 = call i32 @exit(i32 %24)
unreachable
26: ; preds = %2
%27 = load i32, i32* %4
%28 = icmp eq i32 %27, 2
br i1 %28, label %29, label %30
29: ; preds = %26
store i32 0, i32* %14
br label %31
30: ; preds = %26
store i32 1, i32* %14
br label %31
31: ; preds = %30, %29
%32 = load i8**, i8*** %5
%33 = getelementptr inbounds i8*, i8** %32, i64 1
%34 = load i8*, i8** %33
%35 = call i32 @atoi(i8* %34)
store i32 %35, i32* %6
%36 = load i32, i32* %6
%37 = icmp sle i32 %36, 0
br i1 %37, label %38, label %39
38: ; preds = %31
store i32 1, i32* %6
br label %39
39: ; preds = %38, %31
%40 = call double (...) @stoptime()
%41 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 0
store double %40, double* %41
%42 = load i32, i32* %6
%43 = load i32, i32* %6
%44 = call double** @dmatrix(i32 %42, i32 %43)
store double** %44, double*** %7
%45 = load i32, i32* %6
%46 = call double* @dvector(i32 %45)
store double* %46, double** %8
%47 = load i32, i32* %6
%48 = call double* @dvector(i32 %47)
store double* %48, double** %9
%49 = load i32, i32* %6
%50 = call double* @dvector(i32 %49)
store double* %50, double** %10
%51 = load i32, i32* %6
%52 = call double* @dvector(i32 %51)
store double* %52, double** %11
%53 = call double (...) @stoptime()
%54 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 0
%55 = load double, double* %54
%56 = fsub double %53, %55
%57 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 0
store double %56, double* %57
%58 = call double (...) @stoptime()
%59 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 1
store double %58, double* %59
%60 = call i32 @time(i32* null)
%61 = call i32 @srand(i32 %60)
%62 = load i32, i32* %6
%63 = load double**, double*** %7
%64 = call i32 @rand_matrix(i32 %62, double** %63)
%65 = load i32, i32* %6
%66 = load double*, double** %10
%67 = call i32 @rand_vector(i32 %65, double* %66)
%68 = call double (...) @stoptime()
%69 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 1
%70 = load double, double* %69
%71 = fsub double %68, %70
%72 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 1
store double %71, double* %72
%73 = call double (...) @stoptime()
%74 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 2
store double %73, double* %74
%75 = load i32, i32* %6
%76 = load i32, i32* %6
%77 = load double*, double** %8
%78 = load double**, double*** %7
%79 = load double*, double** %10
%80 = call i32 @d_Ax(i32 %75, i32 %76, double* %77, double** %78, double* %79)
%81 = call double (...) @stoptime()
%82 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 2
%83 = load double, double* %82
%84 = fsub double %81, %83
%85 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 2
store double %84, double* %85
%86 = load i32, i32* %14
%87 = icmp ne i32 %86, 0
br i1 %87, label %92, label %88
88: ; preds = %39
%89 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0))
%90 = load i32, i32* @stdout
%91 = call i32 @fflush(i32 %90)
br label %92
92: ; preds = %88, %39
%93 = call double (...) @stoptime()
%94 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 3
store double %93, double* %94
%95 = load i32, i32* %6
%96 = load double*, double** %9
%97 = load double**, double*** %7
%98 = load double*, double** %8
%99 = call i32 @solve(i32 %95, double* %96, double** %97, double* %98)
%100 = call double (...) @stoptime()
%101 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 3
%102 = load double, double* %101
%103 = fsub double %100, %102
%104 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 3
store double %103, double* %104
%105 = load i32, i32* %14
%106 = icmp ne i32 %105, 0
br i1 %106, label %111, label %107
107: ; preds = %92
%108 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0))
%109 = load i32, i32* @stdout
%110 = call i32 @fflush(i32 %109)
br label %111
111: ; preds = %107, %92
%112 = load i32, i32* %6
%113 = load double*, double** %11
%114 = load double*, double** %10
%115 = load double*, double** %9
%116 = call i32 @d_axpy(i32 %112, double* %113, double -1.000000e+00, double* %114, double* %115)
%117 = load i32, i32* %6
%118 = load double*, double** %11
%119 = call double @norm2(i32 %117, double* %118)
store double %119, double* %12
%120 = load i32, i32* %14
%121 = icmp ne i32 %120, 0
br i1 %121, label %125, label %122
122: ; preds = %111
%123 = load double, double* %12
%124 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0), double %123)
br label %125
125: ; preds = %122, %111
%126 = call double (...) @stoptime()
%127 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 4
%128 = load double, double* %127
%129 = fsub double %126, %128
%130 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 4
store double %129, double* %130
%131 = load i8**, i8*** %5
%132 = getelementptr inbounds i8*, i8** %131, i64 0
%133 = load i8*, i8** %132
%134 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 0
%135 = load i32, i32* %6
%136 = load double, double* %12
%137 = load i32, i32* %14
%138 = call i32 @print_timing(i8* %133, double* %134, i32 %135, double %136, i32 %137)
%139 = load i32, i32* @EXIT_SUCCESS
ret i32 %139
}

LLVM IR (-O2):
@.str = [35 x i8] c"usage: %s <matrix order> [csvout]\0A\00"
@EXIT_FAILURE = global i32 0
@.str.1 = [13 x i8] c"solving ... \00"
@stdout = global i32 0
@.str.3 = [29 x i8] c"The norm of the error is %e\0A\00"
@EXIT_SUCCESS = global i32 0
@str = [9 x i8] c"finished\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca [5 x double]
%4 = bitcast [5 x double]* %3 to i8*
%5 = tail call double (...) @stoptime()
%6 = getelementptr inbounds [5 x double], [5 x double]* %3, i64 0, i64 4
store double %5, double* %6
%7 = icmp slt i32 %0, 2
br i1 %7, label %8, label %13
8: ; preds = %2
%9 = load i8*, i8** %1
%10 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([35 x i8], [35 x i8]* @.str, i64 0, i64 0), i8* %9)
%11 = load i32, i32* @EXIT_FAILURE
%12 = tail call i32 @exit(i32 %11)
unreachable
13: ; preds = %2
%14 = icmp eq i32 %0, 2
%15 = getelementptr inbounds i8*, i8** %1, i64 1
%16 = load i8*, i8** %15
%17 = tail call i32 @atoi(i8* %16)
%18 = icmp sgt i32 %17, 1
%19 = select i1 %18, i32 %17, i32 1
%20 = tail call double (...) @stoptime()
%21 = tail call double** @dmatrix(i32 %19, i32 %19)
%22 = tail call double* @dvector(i32 %19)
%23 = tail call double* @dvector(i32 %19)
%24 = tail call double* @dvector(i32 %19)
%25 = tail call double* @dvector(i32 %19)
%26 = tail call double (...) @stoptime()
%27 = tail call double (...) @stoptime()
%28 = tail call i32 @time(i32* null)
%29 = tail call i32 @srand(i32 %28)
%30 = tail call i32 @rand_matrix(i32 %19, double** %21)
%31 = tail call i32 @rand_vector(i32 %19, double* %24)
%32 = tail call double (...) @stoptime()
%33 = insertelement <2 x double> poison, double %26, i64 0
%34 = insertelement <2 x double> %33, double %32, i64 1
%35 = insertelement <2 x double> poison, double %20, i64 0
%36 = insertelement <2 x double> %35, double %27, i64 1
%37 = fsub <2 x double> %34, %36
%38 = bitcast [5 x double]* %3 to <2 x double>*
store <2 x double> %37, <2 x double>* %38
%39 = tail call double (...) @stoptime()
%40 = getelementptr inbounds [5 x double], [5 x double]* %3, i64 0, i64 2
%41 = tail call i32 @d_Ax(i32 %19, i32 %19, double* %22, double** %21, double* %24)
%42 = tail call double (...) @stoptime()
%43 = fsub double %42, %39
store double %43, double* %40
br i1 %14, label %44, label %56
44: ; preds = %13
%45 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0))
%46 = load i32, i32* @stdout
%47 = tail call i32 @fflush(i32 %46)
%48 = tail call double (...) @stoptime()
%49 = getelementptr inbounds [5 x double], [5 x double]* %3, i64 0, i64 3
%50 = tail call i32 @solve(i32 %19, double* %23, double** %21, double* %22)
%51 = tail call double (...) @stoptime()
%52 = fsub double %51, %48
store double %52, double* %49
%53 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @str, i64 0, i64 0))
%54 = load i32, i32* @stdout
%55 = tail call i32 @fflush(i32 %54)
br label %62
56: ; preds = %13
%57 = tail call double (...) @stoptime()
%58 = getelementptr inbounds [5 x double], [5 x double]* %3, i64 0, i64 3
%59 = tail call i32 @solve(i32 %19, double* %23, double** %21, double* %22)
%60 = tail call double (...) @stoptime()
%61 = fsub double %60, %57
store double %61, double* %58
br label %62
62: ; preds = %56, %44
%63 = tail call i32 @d_axpy(i32 %19, double* %25, double -1.000000e+00, double* %24, double* %23)
%64 = tail call double @norm2(i32 %19, double* %25)
br i1 %14, label %65, label %67
65: ; preds = %62
%66 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0), double %64)
br label %67
67: ; preds = %65, %62
%68 = getelementptr inbounds [5 x double], [5 x double]* %3, i64 0, i64 0
%69 = xor i1 %14, true
%70 = zext i1 %69 to i32
%71 = tail call double (...) @stoptime()
%72 = fsub double %71, %5
store double %72, double* %6
%73 = load i8*, i8** %1
%74 = call i32 @print_timing(i8* %73, double* %68, i32 %19, double %64, i32 %70)
%75 = load i32, i32* @EXIT_SUCCESS
ret i32 %75
}