#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 /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int fscanf(int /*<<< orphan*/ *, char *, double *, double *, ...);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ stderr;
void readcols(char *fname, double x[], double y[], double z[], size_t N,
              int three, int unit, int quiet) {
  FILE *infile = fopen(fname, "r");
  if (three == 0) {
    for (size_t i = 0; i < N + 1; ++i) {
      if (fscanf(infile, "%lf%lf", &x[i], &y[i]) != 2)
        break;
    }
  } else {
    if (quiet == 0)
      printf(" -- INFO: Using weights\n");
    for (size_t i = 0; i < N + 1; ++i) {
      if (fscanf(infile, "%lf%lf%lf", &x[i], &y[i], &z[i]) != 3)
        break;
    }
  }
  fclose(infile);
  if (unit != 1) {
    double scaling = 1;
    if (unit == 2) {
      scaling = 86400.0;
      if (quiet == 0)
        printf(" -- INFO: Unit is %s\n", "days");
    } else if (unit == 3) {
      scaling = 1e6;
      if (quiet == 0)
        printf(" -- INFO: Unit is %s\n", "megaseconds");
    } else {
      fprintf(stderr, "Error: Wrong unit. Assuming seconds.\n");
    }
    for (size_t j = 0; j < N + 1; ++j) {
      x[j] *= scaling;
    }
  } else {
    if (quiet == 0)
      printf(" -- INFO: Unit is %s\n", "seconds");
  }
}


x86 assembly (clang, -O0):
<readcols>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xe97(%rip),%rsi
call   1070 <fopen@plt>
mov    %rax,-0x38(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jne    120a <readcols+0xba>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rcx
add    $0x1,%rcx
cmp    %rcx,%rax
jae    1205 <readcols+0xb5>
mov    -0x38(%rbp),%rdi
mov    -0x10(%rbp),%rdx
mov    -0x40(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x18(%rbp),%rcx
mov    -0x40(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rcx
lea    0xe5c(%rip),%rsi
mov    $0x0,%al
call   1050 <fscanf@plt>
cmp    $0x2,%eax
je     11ef <readcols+0x9f>
jmp    1205 <readcols+0xb5>
jmp    11f4 <readcols+0xa4>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    119c <readcols+0x4c>
jmp    12a7 <readcols+0x157>
cmpl   $0x0,0x18(%rbp)
jne    1222 <readcols+0xd2>
lea    0xdff(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%rcx
add    $0x1,%rcx
cmp    %rcx,%rax
jae    12a2 <readcols+0x152>
mov    -0x38(%rbp),%rdi
mov    -0x10(%rbp),%rdx
mov    -0x48(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x18(%rbp),%rcx
mov    -0x48(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rcx
mov    -0x20(%rbp),%r8
mov    -0x48(%rbp),%rax
shl    $0x3,%rax
add    %rax,%r8
lea    0xdbc(%rip),%rsi
mov    $0x0,%al
call   1050 <fscanf@plt>
cmp    $0x3,%eax
je     128c <readcols+0x13c>
jmp    12a2 <readcols+0x152>
jmp    1291 <readcols+0x141>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    122a <readcols+0xda>
jmp    12a7 <readcols+0x157>
mov    -0x38(%rbp),%rdi
call   1030 <fclose@plt>
cmpl   $0x1,0x10(%rbp)
je     13a1 <readcols+0x251>
movsd  0xd3e(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
cmpl   $0x2,0x10(%rbp)
jne    1302 <readcols+0x1b2>
movsd  0xd37(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
cmpl   $0x0,0x18(%rbp)
jne    12fd <readcols+0x1ad>
lea    0xd4e(%rip),%rdi
lea    0xd5d(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1357 <readcols+0x207>
cmpl   $0x3,0x10(%rbp)
jne    133d <readcols+0x1ed>
movsd  0xcf4(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
cmpl   $0x0,0x18(%rbp)
jne    1338 <readcols+0x1e8>
lea    0xd13(%rip),%rdi
lea    0xd27(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1352 <readcols+0x202>
mov    0x2c9c(%rip),%rax
mov    (%rax),%edi
lea    0xd17(%rip),%rsi
call   1060 <fprintf@plt>
jmp    1357 <readcols+0x207>
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%rcx
add    $0x1,%rcx
cmp    %rcx,%rax
jae    139c <readcols+0x24c>
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    135f <readcols+0x20f>
jmp    13c5 <readcols+0x275>
cmpl   $0x0,0x18(%rbp)
jne    13c0 <readcols+0x270>
lea    0xc8b(%rip),%rdi
lea    0xca3(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    13c5 <readcols+0x275>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<readcols>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r9d,%r15d
mov    %r8,%r12
mov    %rcx,%r13
mov    %rdx,%rbx
mov    %rsi,%r14
mov    0x68(%rsp),%ebp
mov    0x60(%rsp),%eax
mov    %eax,0x1c(%rsp)
lea    0xe88(%rip),%rsi
call   1080 <fopen@plt>
mov    %rax,0x10(%rsp)
test   %r15d,%r15d
mov    %r12,0x20(%rsp)
mov    %ebp,0xc(%rsp)
je     120c <readcols+0xac>
test   %ebp,%ebp
jne    11b8 <readcols+0x58>
lea    0xebe(%rip),%rdi
call   1030 <puts@plt>
mov    %r12,%rbp
inc    %rbp
je     125f <readcols+0xff>
mov    $0x1,%r12d
mov    %r14,%r15
nopl   (%rax)
mov    0x10(%rsp),%rdi
lea    0xe3e(%rip),%rsi
mov    %r15,%rdx
mov    %rbx,%rcx
mov    %r13,%r8
xor    %eax,%eax
call   1060 <fscanf@plt>
cmp    $0x3,%eax
jne    125f <readcols+0xff>
lea    0x1(%r12),%rax
add    $0x8,%r13
add    $0x8,%rbx
add    $0x8,%r15
cmp    %rbp,%r12
mov    %rax,%r12
jb     11d0 <readcols+0x70>
jmp    125f <readcols+0xff>
mov    %r12,%r13
inc    %r13
je     125f <readcols+0xff>
mov    $0x1,%r12d
lea    0xdfc(%rip),%r15
mov    %r14,%rbp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x10(%rsp),%rdi
mov    %r15,%rsi
mov    %rbp,%rdx
mov    %rbx,%rcx
xor    %eax,%eax
call   1060 <fscanf@plt>
cmp    $0x2,%eax
jne    125f <readcols+0xff>
lea    0x1(%r12),%rax
add    $0x8,%rbx
add    $0x8,%rbp
cmp    %r13,%r12
mov    %rax,%r12
jb     1230 <readcols+0xd0>
mov    0x10(%rsp),%rdi
call   1040 <fclose@plt>
mov    0x1c(%rsp),%eax
cmp    $0x1,%eax
je     12b7 <readcols+0x157>
cmp    $0x3,%eax
je     12e5 <readcols+0x185>
cmp    $0x2,%eax
mov    0x20(%rsp),%rbx
jne    1318 <readcols+0x1b8>
movsd  0xd7b(%rip),%xmm5
cmpl   $0x0,0xc(%rsp)
jne    1335 <readcols+0x1d5>
lea    0xd85(%rip),%rdi
lea    0xd94(%rip),%rsi
xor    %eax,%eax
call   1050 <printf@plt>
movsd  0xd53(%rip),%xmm5
jmp    1335 <readcols+0x1d5>
cmpl   $0x0,0xc(%rsp)
jne    141b <readcols+0x2bb>
lea    0xd5b(%rip),%rdi
lea    0xd73(%rip),%rsi
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <printf@plt>
movsd  0xd13(%rip),%xmm5
cmpl   $0x0,0xc(%rsp)
mov    0x20(%rsp),%rbx
jne    1335 <readcols+0x1d5>
lea    0xd24(%rip),%rdi
lea    0xd38(%rip),%rsi
xor    %eax,%eax
call   1050 <printf@plt>
movsd  0xcea(%rip),%xmm5
jmp    1335 <readcols+0x1d5>
mov    0x2cc1(%rip),%rax
mov    (%rax),%edi
lea    0xd23(%rip),%rsi
call   1070 <fprintf@plt>
movsd  0xcdb(%rip),%xmm5
cmp    $0xffffffffffffffff,%rbx
je     141b <readcols+0x2bb>
add    $0x1,%rbx
cmp    $0x4,%rbx
jae    1350 <readcols+0x1f0>
xor    %eax,%eax
jmp    1405 <readcols+0x2a5>
mov    %rbx,%rax
and    $0xfffffffffffffffc,%rax
movapd %xmm5,%xmm0
unpcklpd %xmm5,%xmm0
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     13d7 <readcols+0x277>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopl   0x0(%rax)
movupd (%r14,%rcx,8),%xmm1
movupd 0x10(%r14,%rcx,8),%xmm2
movupd 0x20(%r14,%rcx,8),%xmm3
movupd 0x30(%r14,%rcx,8),%xmm4
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,(%r14,%rcx,8)
movupd %xmm2,0x10(%r14,%rcx,8)
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm4
movupd %xmm3,0x20(%r14,%rcx,8)
movupd %xmm4,0x30(%r14,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1380 <readcols+0x220>
test   $0x1,%dl
jne    13de <readcols+0x27e>
jmp    1400 <readcols+0x2a0>
xor    %ecx,%ecx
test   $0x1,%dl
je     1400 <readcols+0x2a0>
movupd (%r14,%rcx,8),%xmm1
movupd 0x10(%r14,%rcx,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,(%r14,%rcx,8)
movupd %xmm2,0x10(%r14,%rcx,8)
cmp    %rax,%rbx
je     141b <readcols+0x2bb>
movsd  (%r14,%rax,8),%xmm0
mulsd  %xmm5,%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
jmp    1400 <readcols+0x2a0>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [2 x i8] c"r\00"
@.str.1 = [7 x i8] c"%lf%lf\00"
@.str.2 = [25 x i8] c" -- INFO: Using weights\0A\00"
@.str.3 = [10 x i8] c"%lf%lf%lf\00"
@.str.4 = [22 x i8] c" -- INFO: Unit is %s\0A\00"
@.str.5 = [5 x i8] c"days\00"
@.str.6 = [12 x i8] c"megaseconds\00"
@stderr = global i32 0
@.str.7 = [38 x i8] c"Error: Wrong unit. Assuming seconds.\0A\00"
@.str.8 = [8 x i8] c"seconds\00"
define void @readcols(i8* %0, double* %1, double* %2, double* %3, i64 %4, i32 %5, i32 %6, i32 %7) {
%9 = alloca i8*
%10 = alloca double*
%11 = alloca double*
%12 = alloca double*
%13 = alloca i64
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32*
%18 = alloca i64
%19 = alloca i64
%20 = alloca double
%21 = alloca i64
store i8* %0, i8** %9
store double* %1, double** %10
store double* %2, double** %11
store double* %3, double** %12
store i64 %4, i64* %13
store i32 %5, i32* %14
store i32 %6, i32* %15
store i32 %7, i32* %16
%22 = load i8*, i8** %9
%23 = call i32* @fopen(i8* %22, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
store i32* %23, i32** %17
%24 = load i32, i32* %14
%25 = icmp eq i32 %24, 0
br i1 %25, label %26, label %48
26: ; preds = %8
store i64 0, i64* %18
br label %27
27: ; preds = %44, %26
%28 = load i64, i64* %18
%29 = load i64, i64* %13
%30 = add i64 %29, 1
%31 = icmp ult i64 %28, %30
br i1 %31, label %32, label %47
32: ; preds = %27
%33 = load i32*, i32** %17
%34 = load double*, double** %10
%35 = load i64, i64* %18
%36 = getelementptr inbounds double, double* %34, i64 %35
%37 = load double*, double** %11
%38 = load i64, i64* %18
%39 = getelementptr inbounds double, double* %37, i64 %38
%40 = call i32 (i32*, i8*, double*, double*, ...) @fscanf(i32* %33, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double* %36, double* %39)
%41 = icmp ne i32 %40, 2
br i1 %41, label %42, label %43
42: ; preds = %32
br label %47
43: ; preds = %32
br label %44
44: ; preds = %43
%45 = load i64, i64* %18
%46 = add i64 %45, 1
store i64 %46, i64* %18
br label %27
47: ; preds = %42, %27
br label %78
48: ; preds = %8
%49 = load i32, i32* %16
%50 = icmp eq i32 %49, 0
br i1 %50, label %51, label %53
51: ; preds = %48
%52 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.2, i64 0, i64 0))
br label %53
53: ; preds = %51, %48
store i64 0, i64* %19
br label %54
54: ; preds = %74, %53
%55 = load i64, i64* %19
%56 = load i64, i64* %13
%57 = add i64 %56, 1
%58 = icmp ult i64 %55, %57
br i1 %58, label %59, label %77
59: ; preds = %54
%60 = load i32*, i32** %17
%61 = load double*, double** %10
%62 = load i64, i64* %19
%63 = getelementptr inbounds double, double* %61, i64 %62
%64 = load double*, double** %11
%65 = load i64, i64* %19
%66 = getelementptr inbounds double, double* %64, i64 %65
%67 = load double*, double** %12
%68 = load i64, i64* %19
%69 = getelementptr inbounds double, double* %67, i64 %68
%70 = call i32 (i32*, i8*, double*, double*, ...) @fscanf(i32* %60, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i64 0, i64 0), double* %63, double* %66, double* %69)
%71 = icmp ne i32 %70, 3
br i1 %71, label %72, label %73
72: ; preds = %59
br label %77
73: ; preds = %59
br label %74
74: ; preds = %73
%75 = load i64, i64* %19
%76 = add i64 %75, 1
store i64 %76, i64* %19
br label %54
77: ; preds = %72, %54
br label %78
78: ; preds = %77, %47
%79 = load i32*, i32** %17
%80 = call i32 @fclose(i32* %79)
%81 = load i32, i32* %15
%82 = icmp ne i32 %81, 1
br i1 %82, label %83, label %122
83: ; preds = %78
store double 1.000000e+00, double* %20
%84 = load i32, i32* %15
%85 = icmp eq i32 %84, 2
br i1 %85, label %86, label %92
86: ; preds = %83
store double 8.640000e+04, double* %20
%87 = load i32, i32* %16
%88 = icmp eq i32 %87, 0
br i1 %88, label %89, label %91
89: ; preds = %86
%90 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
br label %91
91: ; preds = %89, %86
br label %105
92: ; preds = %83
%93 = load i32, i32* %15
%94 = icmp eq i32 %93, 3
br i1 %94, label %95, label %101
95: ; preds = %92
store double 1.000000e+06, double* %20
%96 = load i32, i32* %16
%97 = icmp eq i32 %96, 0
br i1 %97, label %98, label %100
98: ; preds = %95
%99 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.6, i64 0, i64 0))
br label %100
100: ; preds = %98, %95
br label %104
101: ; preds = %92
%102 = load i32, i32* @stderr
%103 = call i32 @fprintf(i32 %102, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.7, i64 0, i64 0))
br label %104
104: ; preds = %101, %100
br label %105
105: ; preds = %104, %91
store i64 0, i64* %21
br label %106
106: ; preds = %118, %105
%107 = load i64, i64* %21
%108 = load i64, i64* %13
%109 = add i64 %108, 1
%110 = icmp ult i64 %107, %109
br i1 %110, label %111, label %121
111: ; preds = %106
%112 = load double, double* %20
%113 = load double*, double** %10
%114 = load i64, i64* %21
%115 = getelementptr inbounds double, double* %113, i64 %114
%116 = load double, double* %115
%117 = fmul double %116, %112
store double %117, double* %115
br label %118
118: ; preds = %111
%119 = load i64, i64* %21
%120 = add i64 %119, 1
store i64 %120, i64* %21
br label %106
121: ; preds = %106
br label %128
122: ; preds = %78
%123 = load i32, i32* %16
%124 = icmp eq i32 %123, 0
br i1 %124, label %125, label %127
125: ; preds = %122
%126 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.8, i64 0, i64 0))
br label %127
127: ; preds = %125, %122
br label %128
128: ; preds = %127, %121
ret void
}

LLVM IR (-O2):
@.str = [2 x i8] c"r\00"
@.str.1 = [7 x i8] c"%lf%lf\00"
@.str.3 = [10 x i8] c"%lf%lf%lf\00"
@.str.4 = [22 x i8] c" -- INFO: Unit is %s\0A\00"
@.str.5 = [5 x i8] c"days\00"
@.str.6 = [12 x i8] c"megaseconds\00"
@stderr = global i32 0
@.str.7 = [38 x i8] c"Error: Wrong unit. Assuming seconds.\0A\00"
@.str.8 = [8 x i8] c"seconds\00"
@str = [24 x i8] c" -- INFO: Using weights\00"
define void @readcols(i8* nocapture %0, double* %1, double* %2, double* %3, i64 %4, i32 %5, i32 %6, i32 %7) {
%9 = tail call i32* @fopen(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%10 = icmp eq i32 %5, 0
br i1 %10, label %11, label %23
11: ; preds = %8
%12 = add i64 %4, 1
%13 = icmp eq i64 %12, 0
br i1 %13, label %40, label %14
14: ; preds = %11, %14
%15 = phi i64 [ %20, %14 ], [ 0, %11 ]
%16 = getelementptr inbounds double, double* %1, i64 %15
%17 = getelementptr inbounds double, double* %2, i64 %15
%18 = tail call i32 (i32*, i8*, double*, double*, ...) @fscanf(i32* %9, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double* %16, double* %17)
%19 = icmp eq i32 %18, 2
%20 = add nuw i64 %15, 1
%21 = icmp ult i64 %20, %12
%22 = select i1 %19, i1 %21, i1 false
br i1 %22, label %14, label %40
23: ; preds = %8
%24 = icmp eq i32 %7, 0
br i1 %24, label %25, label %27
25: ; preds = %23
%26 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @str, i64 0, i64 0))
br label %27
27: ; preds = %25, %23
%28 = add i64 %4, 1
%29 = icmp eq i64 %28, 0
br i1 %29, label %40, label %30
30: ; preds = %27, %30
%31 = phi i64 [ %37, %30 ], [ 0, %27 ]
%32 = getelementptr inbounds double, double* %1, i64 %31
%33 = getelementptr inbounds double, double* %2, i64 %31
%34 = getelementptr inbounds double, double* %3, i64 %31
%35 = tail call i32 (i32*, i8*, double*, double*, ...) @fscanf(i32* %9, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i64 0, i64 0), double* %32, double* %33, double* %34)
%36 = icmp eq i32 %35, 3
%37 = add nuw i64 %31, 1
%38 = icmp ult i64 %37, %28
%39 = select i1 %36, i1 %38, i1 false
br i1 %39, label %30, label %40
40: ; preds = %30, %14, %27, %11
%41 = tail call i32 @fclose(i32* %9)
switch i32 %6, label %50 [
i32 1, label %124
i32 2, label %42
i32 3, label %46
]
42: ; preds = %40
%43 = icmp eq i32 %7, 0
br i1 %43, label %44, label %53
44: ; preds = %42
%45 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
br label %53
46: ; preds = %40
%47 = icmp eq i32 %7, 0
br i1 %47, label %48, label %53
48: ; preds = %46
%49 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.6, i64 0, i64 0))
br label %53
50: ; preds = %40
%51 = load i32, i32* @stderr
%52 = tail call i32 @fprintf(i32 %51, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.7, i64 0, i64 0))
br label %53
53: ; preds = %50, %48, %46, %42, %44
%54 = phi double [ 8.640000e+04, %44 ], [ 8.640000e+04, %42 ], [ 1.000000e+06, %48 ], [ 1.000000e+06, %46 ], [ 1.000000e+00, %50 ]
%55 = icmp eq i64 %4, -1
br i1 %55, label %128, label %56
56: ; preds = %53
%57 = add i64 %4, 1
%58 = icmp ult i64 %57, 4
br i1 %58, label %115, label %59
59: ; preds = %56
%60 = and i64 %57, -4
%61 = insertelement <2 x double> poison, double %54, i64 0
%62 = shufflevector <2 x double> %61, <2 x double> poison, <2 x i32> zeroinitializer
%63 = insertelement <2 x double> poison, double %54, i64 0
%64 = shufflevector <2 x double> %63, <2 x double> poison, <2 x i32> zeroinitializer
%65 = add i64 %60, -4
%66 = lshr exact i64 %65, 2
%67 = add nuw nsw i64 %66, 1
%68 = and i64 %67, 1
%69 = icmp eq i64 %65, 0
br i1 %69, label %99, label %70
70: ; preds = %59
%71 = and i64 %67, 9223372036854775806
br label %72
72: ; preds = %72, %70
%73 = phi i64 [ 0, %70 ], [ %96, %72 ]
%74 = phi i64 [ 0, %70 ], [ %97, %72 ]
%75 = getelementptr inbounds double, double* %1, i64 %73
%76 = bitcast double* %75 to <2 x double>*
%77 = load <2 x double>, <2 x double>* %76
%78 = getelementptr inbounds double, double* %75, i64 2
%79 = bitcast double* %78 to <2 x double>*
%80 = load <2 x double>, <2 x double>* %79
%81 = fmul <2 x double> %62, %77
%82 = fmul <2 x double> %64, %80
%83 = bitcast double* %75 to <2 x double>*
store <2 x double> %81, <2 x double>* %83
%84 = bitcast double* %78 to <2 x double>*
store <2 x double> %82, <2 x double>* %84
%85 = or i64 %73, 4
%86 = getelementptr inbounds double, double* %1, i64 %85
%87 = bitcast double* %86 to <2 x double>*
%88 = load <2 x double>, <2 x double>* %87
%89 = getelementptr inbounds double, double* %86, i64 2
%90 = bitcast double* %89 to <2 x double>*
%91 = load <2 x double>, <2 x double>* %90
%92 = fmul <2 x double> %62, %88
%93 = fmul <2 x double> %64, %91
%94 = bitcast double* %86 to <2 x double>*
store <2 x double> %92, <2 x double>* %94
%95 = bitcast double* %89 to <2 x double>*
store <2 x double> %93, <2 x double>* %95
%96 = add nuw i64 %73, 8
%97 = add i64 %74, 2
%98 = icmp eq i64 %97, %71
br i1 %98, label %99, label %72
99: ; preds = %72, %59
%100 = phi i64 [ 0, %59 ], [ %96, %72 ]
%101 = icmp eq i64 %68, 0
br i1 %101, label %113, label %102
102: ; preds = %99
%103 = getelementptr inbounds double, double* %1, i64 %100
%104 = bitcast double* %103 to <2 x double>*
%105 = load <2 x double>, <2 x double>* %104
%106 = getelementptr inbounds double, double* %103, i64 2
%107 = bitcast double* %106 to <2 x double>*
%108 = load <2 x double>, <2 x double>* %107
%109 = fmul <2 x double> %62, %105
%110 = fmul <2 x double> %64, %108
%111 = bitcast double* %103 to <2 x double>*
store <2 x double> %109, <2 x double>* %111
%112 = bitcast double* %106 to <2 x double>*
store <2 x double> %110, <2 x double>* %112
br label %113
113: ; preds = %99, %102
%114 = icmp eq i64 %57, %60
br i1 %114, label %128, label %115
115: ; preds = %56, %113
%116 = phi i64 [ 0, %56 ], [ %60, %113 ]
br label %117
117: ; preds = %115, %117
%118 = phi i64 [ %122, %117 ], [ %116, %115 ]
%119 = getelementptr inbounds double, double* %1, i64 %118
%120 = load double, double* %119
%121 = fmul double %54, %120
store double %121, double* %119
%122 = add nuw i64 %118, 1
%123 = icmp eq i64 %118, %4
br i1 %123, label %128, label %117
124: ; preds = %40
%125 = icmp eq i32 %7, 0
br i1 %125, label %126, label %128
126: ; preds = %124
%127 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.8, i64 0, i64 0))
br label %128
128: ; preds = %117, %113, %53, %124, %126
ret void
}