#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 */
scalar_t__ EOF;
int /*<<< orphan*/ EXIT_FAILURE;
int /*<<< orphan*/ EXIT_SUCCESS;
int /*<<< orphan*/ abort();
double atof(char *);
int /*<<< orphan*/ exit(int /*<<< orphan*/);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
scalar_t__ fscanf(int /*<<< orphan*/ *, char *, double *);
int getopt(int, char **, char *);
double l1tf_lambdamax(int, double *);
double *malloc(int);
scalar_t__ optind;
double *realloc(double *, int);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ stdout;
void process_args(int argc, char *argv[], int *pn, double **py, double *plambda,
                  double *plambda_max) {
  FILE *fp;
  char *ifile_y;
  int c, n, buf_size;
  double lambda, lambda_max, val;
  double *buf_start, *buf_end, *buf_pos;
  int rflag = 0;
  while ((c = getopt(argc, argv, "r")) != -1) {
    switch (c) {
    case 'r':
      rflag = 1;
      break;
    default:
      abort();
    }
  }
  argc -= optind;
  argv += optind;
  switch (argc) {
  case 2:
    lambda = atof(argv[1]);
    ifile_y = argv[0];
    break;
  case 1:
    lambda = 0.1;
    ifile_y = argv[0];
    break;
  default:
    fprintf(stdout, "usage: l1tf [-r] in_file [lambda] [> out_file]\n");
    exit(EXIT_SUCCESS);
  }
  if ((fp = fopen(ifile_y, "r")) == NULL) {
    fprintf(stderr, "ERROR: Could not open file: %s\n", ifile_y);
    exit(EXIT_FAILURE);
  }
  buf_size = 4096;
  buf_start = malloc(sizeof(double) * buf_size);
  buf_end = buf_start + buf_size;
  buf_pos = buf_start;
  n = 0;
  while (fscanf(fp, "%lg\n", &val) != EOF) {
    n++;
    *buf_pos++ = val;
    if (buf_pos >= buf_end) {
      buf_start = realloc(buf_start, sizeof(double) * buf_size * 2);
      if (buf_start == NULL)
        exit(EXIT_FAILURE);
      buf_pos = buf_start + buf_size;
      buf_size *= 2;
      buf_end = buf_start + buf_size;
    }
  }
  fclose(fp);
  lambda_max = l1tf_lambdamax(n, buf_start);
  if (rflag == 1)
    lambda = lambda * lambda_max;
  *plambda_max = lambda_max;
  *plambda = lambda;
  *py = buf_start;
  *pn = n;
}


x86 assembly (clang, -O0):
<process_args>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x10(%rbp),%rsi
lea    0xe1e(%rip),%rdx
call   10c0 <getopt@plt>
mov    %eax,-0x44(%rbp)
cmp    $0xffffffff,%eax
je     1227 <process_args+0x77>
mov    -0x44(%rbp),%eax
sub    $0x72,%eax
jne    121b <process_args+0x6b>
jmp    120c <process_args+0x5c>
movl   $0x1,-0x84(%rbp)
jmp    1222 <process_args+0x72>
mov    $0x0,%al
call   1030 <abort@plt>
jmp    11dc <process_args+0x2c>
mov    0x2db2(%rip),%rax
mov    (%rax),%edx
mov    -0x4(%rbp),%ecx
sub    %edx,%ecx
mov    %ecx,-0x4(%rbp)
mov    (%rax),%rcx
mov    -0x10(%rbp),%rax
lea    (%rax,%rcx,8),%rax
mov    %rax,-0x10(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x88(%rbp)
sub    $0x1,%eax
je     1294 <process_args+0xe4>
jmp    125e <process_args+0xae>
mov    -0x88(%rbp),%eax
sub    $0x2,%eax
jne    12b1 <process_args+0x101>
jmp    1272 <process_args+0xc2>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1040 <atof@plt>
movsd  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x40(%rbp)
jmp    12d6 <process_args+0x126>
movsd  0xd64(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x40(%rbp)
jmp    12d6 <process_args+0x126>
mov    0x2d08(%rip),%rax
mov    (%rax),%edi
lea    0xd49(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    0x2ce9(%rip),%rax
mov    (%rax),%edi
call   10d0 <exit@plt>
mov    -0x40(%rbp),%rdi
lea    0xd27(%rip),%rsi
call   10b0 <fopen@plt>
mov    %rax,-0x38(%rbp)
cmp    $0x0,%rax
jne    131d <process_args+0x16d>
mov    0x2cd5(%rip),%rax
mov    (%rax),%edi
mov    -0x40(%rbp),%rdx
lea    0xd32(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    0x2cb2(%rip),%rax
mov    (%rax),%edi
call   10d0 <exit@plt>
movl   $0x1000,-0x4c(%rbp)
movslq -0x4c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x4c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x38(%rbp),%rdi
lea    0xcf6(%rip),%rsi
lea    -0x68(%rbp),%rdx
call   1070 <fscanf@plt>
mov    0x2c74(%rip),%rcx
cmp    (%rcx),%rax
je     1414 <process_args+0x264>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
movsd  -0x68(%rbp),%xmm0
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x80(%rbp)
movsd  %xmm0,(%rax)
mov    -0x80(%rbp),%rax
cmp    -0x78(%rbp),%rax
jb     140f <process_args+0x25f>
mov    -0x70(%rbp),%rdi
movslq -0x4c(%rbp),%rax
shl    $0x3,%rax
shl    $0x1,%rax
mov    %eax,%esi
call   10a0 <realloc@plt>
mov    %rax,-0x70(%rbp)
cmpq   $0x0,-0x70(%rbp)
jne    13e0 <process_args+0x230>
mov    0x2bef(%rip),%rax
mov    (%rax),%edi
call   10d0 <exit@plt>
mov    -0x70(%rbp),%rax
movslq -0x4c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x4c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x4c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
jmp    1359 <process_args+0x1a9>
mov    -0x38(%rbp),%rdi
call   1060 <fclose@plt>
mov    -0x48(%rbp),%edi
mov    -0x70(%rbp),%rsi
call   1050 <l1tf_lambdamax@plt>
movsd  %xmm0,-0x60(%rbp)
cmpl   $0x1,-0x84(%rbp)
jne    144a <process_args+0x29a>
movsd  -0x58(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x70(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x48(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<process_args>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r9,0x28(%rsp)
mov    %r8,0x30(%rsp)
mov    %rcx,%r13
mov    %rdx,%r15
mov    %rsi,%rbx
mov    %edi,%ebp
xor    %ecx,%ecx
lea    0xe34(%rip),%r14
nopl   0x0(%rax)
mov    %ecx,%r12d
mov    %ebp,%edi
mov    %rbx,%rsi
mov    %r14,%rdx
call   10c0 <getopt@plt>
mov    $0x1,%cl
cmp    $0x72,%eax
je     11e0 <process_args+0x30>
cmp    $0xffffffff,%eax
jne    1376 <process_args+0x1c6>
mov    0x2dd9(%rip),%rax
mov    (%rax),%r14
sub    %r14d,%ebp
cmp    $0x1,%ebp
je     1227 <process_args+0x77>
cmp    $0x2,%ebp
jne    13a5 <process_args+0x1f5>
mov    0x8(%rbx,%r14,8),%rdi
call   1040 <atof@plt>
jmp    122f <process_args+0x7f>
movsd  0xdd1(%rip),%xmm0
movsd  %xmm0,(%rsp)
mov    (%rbx,%r14,8),%rbp
lea    0xdd1(%rip),%rsi
mov    %rbp,%rdi
call   10b0 <fopen@plt>
test   %rax,%rax
je     137d <process_args+0x1cd>
mov    %rax,%rbx
mov    %r13,0x18(%rsp)
mov    %r15,0x20(%rsp)
mov    $0x8000,%edi
call   1090 <malloc@plt>
mov    %rax,%r14
lea    0xdf1(%rip),%rsi
lea    0x10(%rsp),%rdx
mov    %rbx,0x8(%rsp)
mov    %rbx,%rdi
call   1070 <fscanf@plt>
mov    0x2d5e(%rip),%rcx
xor    %ebp,%ebp
cmp    (%rcx),%rax
jne    12f3 <process_args+0x143>
mov    %r14,%r15
mov    0x8(%rsp),%rdi
call   1060 <fclose@plt>
mov    %ebp,%edi
mov    %r15,%rsi
call   1050 <l1tf_lambdamax@plt>
movapd %xmm0,%xmm1
test   $0x1,%r12b
jne    12ba <process_args+0x10a>
movsd  0xd4e(%rip),%xmm1
movsd  (%rsp),%xmm2
mulsd  %xmm1,%xmm2
mov    0x28(%rsp),%rax
movsd  %xmm0,(%rax)
mov    0x30(%rsp),%rax
movsd  %xmm2,(%rax)
mov    0x18(%rsp),%rax
mov    %r15,(%rax)
mov    0x20(%rsp),%rax
mov    %ebp,(%rax)
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r14,%rbx
add    $0x8000,%rbx
xor    %ebp,%ebp
mov    $0x1000,%r13d
mov    %r14,%r15
jmp    1339 <process_args+0x189>
nopw   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rdi
lea    0xd46(%rip),%rsi
lea    0x10(%rsp),%rdx
call   1070 <fscanf@plt>
add    $0x1,%ebp
mov    0x2cb8(%rip),%rcx
cmp    (%rcx),%rax
je     1294 <process_args+0xe4>
movsd  0x10(%rsp),%xmm0
movsd  %xmm0,(%r14)
add    $0x8,%r14
cmp    %rbx,%r14
jb     1310 <process_args+0x160>
mov    %r13d,%esi
shl    $0x4,%esi
mov    %r15,%rdi
call   10a0 <realloc@plt>
test   %rax,%rax
je     1397 <process_args+0x1e7>
mov    %rax,%r15
movslq %r13d,%rax
lea    (%r15,%rax,8),%r14
add    %r13d,%r13d
movslq %r13d,%rax
lea    (%r15,%rax,8),%rbx
jmp    1310 <process_args+0x160>
xor    %eax,%eax
call   1030 <abort@plt>
mov    0x2c4c(%rip),%rax
mov    (%rax),%edi
lea    0xcb5(%rip),%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    0x2c2a(%rip),%rax
mov    (%rax),%edi
call   10d0 <exit@plt>
mov    0x2c14(%rip),%rax
mov    (%rax),%edi
lea    0xc5d(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    0x2bf5(%rip),%rax
mov    (%rax),%edi
call   10d0 <exit@plt>

LLVM IR (-O0):
@.str = [2 x i8] c"r\00"
@optind = global i64 0
@stdout = global i32 0
@.str.1 = [48 x i8] c"usage: l1tf [-r] in_file [lambda] [> out_file]\0A\00"
@EXIT_SUCCESS = global i32 0
@stderr = global i32 0
@.str.2 = [32 x i8] c"ERROR: Could not open file: %s\0A\00"
@EXIT_FAILURE = global i32 0
@.str.3 = [5 x i8] c"%lg\0A\00"
@EOF = global i64 0
define void @process_args(i32 %0, i8** %1, i32* %2, double** %3, double* %4, double* %5) {
%7 = alloca i32
%8 = alloca i8**
%9 = alloca i32*
%10 = alloca double**
%11 = alloca double*
%12 = alloca double*
%13 = alloca i32*
%14 = alloca i8*
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double*
%22 = alloca double*
%23 = alloca double*
%24 = alloca i32
store i32 %0, i32* %7
store i8** %1, i8*** %8
store i32* %2, i32** %9
store double** %3, double*** %10
store double* %4, double** %11
store double* %5, double** %12
store i32 0, i32* %24
br label %25
25: ; preds = %35, %6
%26 = load i32, i32* %7
%27 = load i8**, i8*** %8
%28 = call i32 @getopt(i32 %26, i8** %27, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
store i32 %28, i32* %15
%29 = icmp ne i32 %28, -1
br i1 %29, label %30, label %36
30: ; preds = %25
%31 = load i32, i32* %15
switch i32 %31, label %33 [
i32 114, label %32
]
32: ; preds = %30
store i32 1, i32* %24
br label %35
33: ; preds = %30
%34 = call i32 (...) @abort()
unreachable
35: ; preds = %32
br label %25
36: ; preds = %25
%37 = load i64, i64* @optind
%38 = load i32, i32* %7
%39 = sext i32 %38 to i64
%40 = sub nsw i64 %39, %37
%41 = trunc i64 %40 to i32
store i32 %41, i32* %7
%42 = load i64, i64* @optind
%43 = load i8**, i8*** %8
%44 = getelementptr inbounds i8*, i8** %43, i64 %42
store i8** %44, i8*** %8
%45 = load i32, i32* %7
switch i32 %45, label %58 [
i32 2, label %46
i32 1, label %54
]
46: ; preds = %36
%47 = load i8**, i8*** %8
%48 = getelementptr inbounds i8*, i8** %47, i64 1
%49 = load i8*, i8** %48
%50 = call double @atof(i8* %49)
store double %50, double* %18
%51 = load i8**, i8*** %8
%52 = getelementptr inbounds i8*, i8** %51, i64 0
%53 = load i8*, i8** %52
store i8* %53, i8** %14
br label %63
54: ; preds = %36
store double 1.000000e-01, double* %18
%55 = load i8**, i8*** %8
%56 = getelementptr inbounds i8*, i8** %55, i64 0
%57 = load i8*, i8** %56
store i8* %57, i8** %14
br label %63
58: ; preds = %36
%59 = load i32, i32* @stdout
%60 = call i32 (i32, i8*, ...) @fprintf(i32 %59, i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.1, i64 0, i64 0))
%61 = load i32, i32* @EXIT_SUCCESS
%62 = call i32 @exit(i32 %61)
unreachable
63: ; preds = %54, %46
%64 = load i8*, i8** %14
%65 = call i32* @fopen(i8* %64, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
store i32* %65, i32** %13
%66 = icmp eq i32* %65, null
br i1 %66, label %67, label %73
67: ; preds = %63
%68 = load i32, i32* @stderr
%69 = load i8*, i8** %14
%70 = call i32 (i32, i8*, ...) @fprintf(i32 %68, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.2, i64 0, i64 0), i8* %69)
%71 = load i32, i32* @EXIT_FAILURE
%72 = call i32 @exit(i32 %71)
unreachable
73: ; preds = %63
store i32 4096, i32* %17
%74 = load i32, i32* %17
%75 = sext i32 %74 to i64
%76 = mul i64 8, %75
%77 = trunc i64 %76 to i32
%78 = call double* @malloc(i32 %77)
store double* %78, double** %21
%79 = load double*, double** %21
%80 = load i32, i32* %17
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds double, double* %79, i64 %81
store double* %82, double** %22
%83 = load double*, double** %21
store double* %83, double** %23
store i32 0, i32* %16
br label %84
84: ; preds = %122, %73
%85 = load i32*, i32** %13
%86 = call i64 @fscanf(i32* %85, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), double* %20)
%87 = load i64, i64* @EOF
%88 = icmp ne i64 %86, %87
br i1 %88, label %89, label %123
89: ; preds = %84
%90 = load i32, i32* %16
%91 = add nsw i32 %90, 1
store i32 %91, i32* %16
%92 = load double, double* %20
%93 = load double*, double** %23
%94 = getelementptr inbounds double, double* %93, i32 1
store double* %94, double** %23
store double %92, double* %93
%95 = load double*, double** %23
%96 = load double*, double** %22
%97 = icmp uge double* %95, %96
br i1 %97, label %98, label %122
98: ; preds = %89
%99 = load double*, double** %21
%100 = load i32, i32* %17
%101 = sext i32 %100 to i64
%102 = mul i64 8, %101
%103 = mul i64 %102, 2
%104 = trunc i64 %103 to i32
%105 = call double* @realloc(double* %99, i32 %104)
store double* %105, double** %21
%106 = load double*, double** %21
%107 = icmp eq double* %106, null
br i1 %107, label %108, label %111
108: ; preds = %98
%109 = load i32, i32* @EXIT_FAILURE
%110 = call i32 @exit(i32 %109)
unreachable
111: ; preds = %98
%112 = load double*, double** %21
%113 = load i32, i32* %17
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds double, double* %112, i64 %114
store double* %115, double** %23
%116 = load i32, i32* %17
%117 = mul nsw i32 %116, 2
store i32 %117, i32* %17
%118 = load double*, double** %21
%119 = load i32, i32* %17
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds double, double* %118, i64 %120
store double* %121, double** %22
br label %122
122: ; preds = %111, %89
br label %84
123: ; preds = %84
%124 = load i32*, i32** %13
%125 = call i32 @fclose(i32* %124)
%126 = load i32, i32* %16
%127 = load double*, double** %21
%128 = call double @l1tf_lambdamax(i32 %126, double* %127)
store double %128, double* %19
%129 = load i32, i32* %24
%130 = icmp eq i32 %129, 1
br i1 %130, label %131, label %135
131: ; preds = %123
%132 = load double, double* %18
%133 = load double, double* %19
%134 = fmul double %132, %133
store double %134, double* %18
br label %135
135: ; preds = %131, %123
%136 = load double, double* %19
%137 = load double*, double** %12
store double %136, double* %137
%138 = load double, double* %18
%139 = load double*, double** %11
store double %138, double* %139
%140 = load double*, double** %21
%141 = load double**, double*** %10
store double* %140, double** %141
%142 = load i32, i32* %16
%143 = load i32*, i32** %9
store i32 %142, i32* %143
ret void
}

LLVM IR (-O2):
@.str = [2 x i8] c"r\00"
@optind = global i64 0
@stdout = global i32 0
@.str.1 = [48 x i8] c"usage: l1tf [-r] in_file [lambda] [> out_file]\0A\00"
@EXIT_SUCCESS = global i32 0
@stderr = global i32 0
@.str.2 = [32 x i8] c"ERROR: Could not open file: %s\0A\00"
@EXIT_FAILURE = global i32 0
@.str.3 = [5 x i8] c"%lg\0A\00"
@EOF = global i64 0
define void @process_args(i32 %0, i8** %1, i32* nocapture writeonly %2, double** nocapture writeonly %3, double* nocapture writeonly %4, double* nocapture writeonly %5) {
%7 = alloca double
%8 = bitcast double* %7 to i8*
br label %9
9: ; preds = %9, %6
%10 = phi i1 [ false, %6 ], [ true, %9 ]
%11 = tail call i32 @getopt(i32 %0, i8** %1, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
switch i32 %11, label %12 [
i32 -1, label %14
i32 114, label %9
]
12: ; preds = %9
%13 = tail call i32 (...) @abort()
unreachable
14: ; preds = %9
%15 = load i64, i64* @optind
%16 = trunc i64 %15 to i32
%17 = sub i32 %0, %16
%18 = getelementptr inbounds i8*, i8** %1, i64 %15
switch i32 %17, label %23 [
i32 2, label %19
i32 1, label %28
]
19: ; preds = %14
%20 = getelementptr inbounds i8*, i8** %18, i64 1
%21 = load i8*, i8** %20
%22 = tail call double @atof(i8* %21)
br label %28
23: ; preds = %14
%24 = load i32, i32* @stdout
%25 = tail call i32 (i32, i8*, ...) @fprintf(i32 %24, i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.1, i64 0, i64 0))
%26 = load i32, i32* @EXIT_SUCCESS
%27 = tail call i32 @exit(i32 %26)
unreachable
28: ; preds = %14, %19
%29 = phi double [ %22, %19 ], [ 1.000000e-01, %14 ]
%30 = load i8*, i8** %18
%31 = tail call i32* @fopen(i8* %30, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%32 = icmp eq i32* %31, null
br i1 %32, label %33, label %38
33: ; preds = %28
%34 = load i32, i32* @stderr
%35 = tail call i32 (i32, i8*, ...) @fprintf(i32 %34, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.2, i64 0, i64 0), i8* %30)
%36 = load i32, i32* @EXIT_FAILURE
%37 = tail call i32 @exit(i32 %36)
unreachable
38: ; preds = %28
%39 = tail call double* @malloc(i32 32768)
%40 = call i64 @fscanf(i32* %31, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), double* %7)
%41 = load i64, i64* @EOF
%42 = icmp eq i64 %40, %41
br i1 %42, label %76, label %43
43: ; preds = %38
%44 = getelementptr inbounds double, double* %39, i64 4096
br label %45
45: ; preds = %43, %68
%46 = phi double* [ %72, %68 ], [ %39, %43 ]
%47 = phi double* [ %71, %68 ], [ %44, %43 ]
%48 = phi double* [ %70, %68 ], [ %39, %43 ]
%49 = phi i32 [ %69, %68 ], [ 4096, %43 ]
%50 = phi i32 [ %51, %68 ], [ 0, %43 ]
%51 = add nuw nsw i32 %50, 1
%52 = load double, double* %7
%53 = getelementptr inbounds double, double* %46, i64 1
store double %52, double* %46
%54 = icmp ult double* %53, %47
br i1 %54, label %68, label %55
55: ; preds = %45
%56 = shl i32 %49, 4
%57 = call double* @realloc(double* %48, i32 %56)
%58 = icmp eq double* %57, null
br i1 %58, label %59, label %62
59: ; preds = %55
%60 = load i32, i32* @EXIT_FAILURE
%61 = call i32 @exit(i32 %60)
unreachable
62: ; preds = %55
%63 = sext i32 %49 to i64
%64 = getelementptr inbounds double, double* %57, i64 %63
%65 = shl nsw i32 %49, 1
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds double, double* %57, i64 %66
br label %68
68: ; preds = %62, %45
%69 = phi i32 [ %65, %62 ], [ %49, %45 ]
%70 = phi double* [ %57, %62 ], [ %48, %45 ]
%71 = phi double* [ %67, %62 ], [ %47, %45 ]
%72 = phi double* [ %64, %62 ], [ %53, %45 ]
%73 = call i64 @fscanf(i32* %31, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), double* %7)
%74 = load i64, i64* @EOF
%75 = icmp eq i64 %73, %74
br i1 %75, label %76, label %45
76: ; preds = %68, %38
%77 = phi i32 [ 0, %38 ], [ %51, %68 ]
%78 = phi double* [ %39, %38 ], [ %70, %68 ]
%79 = call i32 @fclose(i32* %31)
%80 = call double @l1tf_lambdamax(i32 %77, double* %78)
%81 = select i1 %10, double %80, double 1.000000e+00
%82 = fmul double %29, %81
store double %80, double* %5
store double %82, double* %4
store double* %78, double** %3
store i32 %77, i32* %2
ret void
}