#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*/ bin_equnumber(double *, int, int, double **, double **);
double *darray(int /*<<< orphan*/, int);
int floor(int /*<<< orphan*/);
int /*<<< orphan*/ free_darray(double *, int /*<<< orphan*/, int);
int /*<<< orphan*/ sqrt(int);
double Mc_maxcurv(double *mags, int N) {
  double *bin_c, *bin_h;
  double f = 0.0;
  double *mags2;
  int Nbin = floor(sqrt(N)), ind;
  mags2 = darray(0, N - 1);
  for (int i = 0; i < N; i++)
    mags2[i] = mags[i];
  bin_equnumber(mags2, N, Nbin, &bin_c, &bin_h);
  for (int i = 0; i < Nbin; i++) {
    if (f <= bin_h[i]) {
      f = bin_h[i];
      ind = i;
    }
  }
  free_darray(mags2, 0, N);
  return bin_c[ind];
}


x86 assembly (clang, -O0):
<Mc_maxcurv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0xc(%rbp),%edi
call   1050 <sqrt@plt>
mov    %eax,%edi
call   1070 <floor@plt>
mov    %eax,-0x34(%rbp)
mov    -0xc(%rbp),%esi
sub    $0x1,%esi
xor    %edi,%edi
call   1040 <darray@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11c5 <Mc_maxcurv+0x75>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1191 <Mc_maxcurv+0x41>
mov    -0x30(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x34(%rbp),%edx
lea    -0x18(%rbp),%rcx
lea    -0x20(%rbp),%r8
call   1060 <bin_equnumber@plt>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1236 <Mc_maxcurv+0xe6>
movsd  -0x28(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     1223 <Mc_maxcurv+0xd3>
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    1228 <Mc_maxcurv+0xd8>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11e3 <Mc_maxcurv+0x93>
mov    -0x30(%rbp),%rdi
mov    -0xc(%rbp),%edx
xor    %esi,%esi
call   1030 <free_darray@plt>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Mc_maxcurv>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x18,%rsp
mov    %esi,%r14d
mov    %rdi,%rbp
mov    %esi,%edi
call   1050 <sqrt@plt>
mov    %eax,%edi
call   1070 <floor@plt>
mov    %eax,%r15d
lea    -0x1(%r14),%esi
xor    %edi,%edi
call   1040 <darray@plt>
mov    %rax,%rbx
test   %r14d,%r14d
jle    12f8 <Mc_maxcurv+0x1a8>
mov    %r14d,%eax
cmp    $0x4,%r14d
jb     11aa <Mc_maxcurv+0x5a>
lea    0x0(,%rax,8),%rcx
add    %rbp,%rcx
cmp    %rcx,%rbx
jae    121d <Mc_maxcurv+0xcd>
lea    (%rbx,%rax,8),%rcx
cmp    %rbp,%rcx
jbe    121d <Mc_maxcurv+0xcd>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     11d5 <Mc_maxcurv+0x85>
xchg   %ax,%ax
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    11c0 <Mc_maxcurv+0x70>
cmp    $0x3,%rdx
jb     12f8 <Mc_maxcurv+0x1a8>
nop
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rcx,8)
movsd  0x10(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rcx,8)
movsd  0x18(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    11e0 <Mc_maxcurv+0x90>
jmp    12f8 <Mc_maxcurv+0x1a8>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%r8d
and    $0x3,%r8d
cmp    $0xc,%rdx
jae    1242 <Mc_maxcurv+0xf2>
xor    %edi,%edi
jmp    12ad <Mc_maxcurv+0x15d>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups 0x0(%rbp,%rdi,8),%xmm0
movups 0x10(%rbp,%rdi,8),%xmm1
movups %xmm0,(%rbx,%rdi,8)
movups %xmm1,0x10(%rbx,%rdi,8)
movups 0x20(%rbp,%rdi,8),%xmm0
movups 0x30(%rbp,%rdi,8),%xmm1
movups %xmm0,0x20(%rbx,%rdi,8)
movups %xmm1,0x30(%rbx,%rdi,8)
movups 0x40(%rbp,%rdi,8),%xmm0
movups 0x50(%rbp,%rdi,8),%xmm1
movups %xmm0,0x40(%rbx,%rdi,8)
movups %xmm1,0x50(%rbx,%rdi,8)
movupd 0x60(%rbp,%rdi,8),%xmm0
movupd 0x70(%rbp,%rdi,8),%xmm1
movupd %xmm0,0x60(%rbx,%rdi,8)
movupd %xmm1,0x70(%rbx,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1250 <Mc_maxcurv+0x100>
test   %r8,%r8
je     12ef <Mc_maxcurv+0x19f>
lea    (%rbx,%rdi,8),%rsi
add    $0x10,%rsi
lea    0x10(,%rdi,8),%rdi
add    %rbp,%rdi
shl    $0x5,%r8
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rdi,%rdx,1),%xmm0
movupd (%rdi,%rdx,1),%xmm1
movupd %xmm0,-0x10(%rsi,%rdx,1)
movupd %xmm1,(%rsi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r8
jne    12d0 <Mc_maxcurv+0x180>
cmp    %rax,%rcx
jne    11ac <Mc_maxcurv+0x5c>
lea    0x10(%rsp),%rcx
lea    0x8(%rsp),%r8
mov    %rbx,%rdi
mov    %r14d,%esi
mov    %r15d,%edx
call   1060 <bin_equnumber@plt>
test   %r15d,%r15d
jle    1338 <Mc_maxcurv+0x1e8>
mov    0x8(%rsp),%rax
mov    %r15d,%r8d
lea    -0x1(%r8),%rdx
mov    %r8d,%ecx
and    $0x3,%ecx
cmp    $0x3,%rdx
jae    133f <Mc_maxcurv+0x1ef>
xorpd  %xmm0,%xmm0
xor    %edx,%edx
jmp    13fd <Mc_maxcurv+0x2ad>
xor    %ebp,%ebp
jmp    1442 <Mc_maxcurv+0x2f2>
and    $0xfffffffc,%r8d
xorpd  %xmm0,%xmm0
xor    %edx,%edx
nopl   0x0(%rax)
movsd  (%rax,%rdx,8),%xmm1
movsd  0x8(%rax,%rdx,8),%xmm2
ucomisd %xmm0,%xmm1
movapd %xmm0,%xmm3
cmpnlesd %xmm1,%xmm3
movapd %xmm3,%xmm4
andnpd %xmm1,%xmm4
andpd  %xmm0,%xmm3
cmovae %edx,%esi
orpd   %xmm4,%xmm3
lea    0x1(%rdx),%ebp
ucomisd %xmm3,%xmm2
movapd %xmm3,%xmm0
cmpnlesd %xmm2,%xmm0
movapd %xmm0,%xmm1
andpd  %xmm3,%xmm1
andnpd %xmm2,%xmm0
orpd   %xmm1,%xmm0
cmovb  %esi,%ebp
movsd  0x10(%rax,%rdx,8),%xmm1
lea    0x2(%rdx),%edi
ucomisd %xmm0,%xmm1
movapd %xmm0,%xmm2
cmpnlesd %xmm1,%xmm2
movapd %xmm2,%xmm3
andpd  %xmm0,%xmm3
andnpd %xmm1,%xmm2
orpd   %xmm3,%xmm2
cmovb  %ebp,%edi
movsd  0x18(%rax,%rdx,8),%xmm1
lea    0x3(%rdx),%esi
ucomisd %xmm2,%xmm1
movapd %xmm2,%xmm0
cmpnlesd %xmm1,%xmm0
movapd %xmm0,%xmm3
andpd  %xmm2,%xmm3
andnpd %xmm1,%xmm0
orpd   %xmm3,%xmm0
cmovb  %edi,%esi
add    $0x4,%rdx
cmp    %r8,%rdx
jne    1350 <Mc_maxcurv+0x200>
test   %rcx,%rcx
je     143f <Mc_maxcurv+0x2ef>
movapd %xmm0,%xmm1
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm2
ucomisd %xmm0,%xmm2
cmpnlesd %xmm2,%xmm1
movapd %xmm1,%xmm3
andnpd %xmm2,%xmm3
andpd  %xmm0,%xmm1
orpd   %xmm3,%xmm1
cmovae %edx,%esi
add    $0x1,%rdx
movapd %xmm1,%xmm0
add    $0xffffffffffffffff,%rcx
jne    1410 <Mc_maxcurv+0x2c0>
movslq %esi,%rbp
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r14d,%edx
call   1030 <free_darray@plt>
mov    0x10(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
add    $0x18,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define double @Mc_maxcurv(double* %0, i32 %1) {
%3 = alloca double*
%4 = alloca i32
%5 = alloca double*
%6 = alloca double*
%7 = alloca double
%8 = alloca double*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
store double* %0, double** %3
store i32 %1, i32* %4
store double 0.000000e+00, double* %7
%13 = load i32, i32* %4
%14 = call i32 @sqrt(i32 %13)
%15 = call i32 @floor(i32 %14)
store i32 %15, i32* %9
%16 = load i32, i32* %4
%17 = sub nsw i32 %16, 1
%18 = call double* @darray(i32 0, i32 %17)
store double* %18, double** %8
store i32 0, i32* %11
br label %19
19: ; preds = %33, %2
%20 = load i32, i32* %11
%21 = load i32, i32* %4
%22 = icmp slt i32 %20, %21
br i1 %22, label %23, label %36
23: ; preds = %19
%24 = load double*, double** %3
%25 = load i32, i32* %11
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds double, double* %24, i64 %26
%28 = load double, double* %27
%29 = load double*, double** %8
%30 = load i32, i32* %11
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds double, double* %29, i64 %31
store double %28, double* %32
br label %33
33: ; preds = %23
%34 = load i32, i32* %11
%35 = add nsw i32 %34, 1
store i32 %35, i32* %11
br label %19
36: ; preds = %19
%37 = load double*, double** %8
%38 = load i32, i32* %4
%39 = load i32, i32* %9
%40 = call i32 @bin_equnumber(double* %37, i32 %38, i32 %39, double** %5, double** %6)
store i32 0, i32* %12
br label %41
41: ; preds = %61, %36
%42 = load i32, i32* %12
%43 = load i32, i32* %9
%44 = icmp slt i32 %42, %43
br i1 %44, label %45, label %64
45: ; preds = %41
%46 = load double, double* %7
%47 = load double*, double** %6
%48 = load i32, i32* %12
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds double, double* %47, i64 %49
%51 = load double, double* %50
%52 = fcmp ole double %46, %51
br i1 %52, label %53, label %60
53: ; preds = %45
%54 = load double*, double** %6
%55 = load i32, i32* %12
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds double, double* %54, i64 %56
%58 = load double, double* %57
store double %58, double* %7
%59 = load i32, i32* %12
store i32 %59, i32* %10
br label %60
60: ; preds = %53, %45
br label %61
61: ; preds = %60
%62 = load i32, i32* %12
%63 = add nsw i32 %62, 1
store i32 %63, i32* %12
br label %41
64: ; preds = %41
%65 = load double*, double** %8
%66 = load i32, i32* %4
%67 = call i32 @free_darray(double* %65, i32 0, i32 %66)
%68 = load double*, double** %5
%69 = load i32, i32* %10
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds double, double* %68, i64 %70
%72 = load double, double* %71
ret double %72
}

LLVM IR (-O2):
define double @Mc_maxcurv(double* nocapture %0, i32 %1) {
%3 = alloca double*
%4 = alloca double*
%5 = bitcast double** %3 to i8*
%6 = bitcast double** %4 to i8*
%7 = tail call i32 @sqrt(i32 %1)
%8 = tail call i32 @floor(i32 %7)
%9 = add nsw i32 %1, -1
%10 = tail call double* @darray(i32 0, i32 %9)
%11 = icmp sgt i32 %1, 0
br i1 %11, label %12, label %118
12: ; preds = %2
%13 = zext i32 %1 to i64
%14 = icmp ult i32 %1, 4
br i1 %14, label %100, label %15
15: ; preds = %12
%16 = getelementptr double, double* %10, i64 %13
%17 = getelementptr double, double* %0, i64 %13
%18 = icmp ult double* %10, %17
%19 = icmp ugt double* %16, %0
%20 = and i1 %18, %19
br i1 %20, label %100, label %21
21: ; preds = %15
%22 = and i64 %13, 4294967292
%23 = add nsw i64 %22, -4
%24 = lshr exact i64 %23, 2
%25 = add nuw nsw i64 %24, 1
%26 = and i64 %25, 3
%27 = icmp ult i64 %23, 12
br i1 %27, label %79, label %28
28: ; preds = %21
%29 = and i64 %25, 9223372036854775804
br label %30
30: ; preds = %30, %28
%31 = phi i64 [ 0, %28 ], [ %76, %30 ]
%32 = phi i64 [ 0, %28 ], [ %77, %30 ]
%33 = getelementptr inbounds double, double* %0, i64 %31
%34 = bitcast double* %33 to <2 x double>*
%35 = load <2 x double>, <2 x double>* %34
%36 = getelementptr inbounds double, double* %33, i64 2
%37 = bitcast double* %36 to <2 x double>*
%38 = load <2 x double>, <2 x double>* %37
%39 = getelementptr inbounds double, double* %10, i64 %31
%40 = bitcast double* %39 to <2 x double>*
store <2 x double> %35, <2 x double>* %40
%41 = getelementptr inbounds double, double* %39, i64 2
%42 = bitcast double* %41 to <2 x double>*
store <2 x double> %38, <2 x double>* %42
%43 = or i64 %31, 4
%44 = getelementptr inbounds double, double* %0, i64 %43
%45 = bitcast double* %44 to <2 x double>*
%46 = load <2 x double>, <2 x double>* %45
%47 = getelementptr inbounds double, double* %44, i64 2
%48 = bitcast double* %47 to <2 x double>*
%49 = load <2 x double>, <2 x double>* %48
%50 = getelementptr inbounds double, double* %10, i64 %43
%51 = bitcast double* %50 to <2 x double>*
store <2 x double> %46, <2 x double>* %51
%52 = getelementptr inbounds double, double* %50, i64 2
%53 = bitcast double* %52 to <2 x double>*
store <2 x double> %49, <2 x double>* %53
%54 = or i64 %31, 8
%55 = getelementptr inbounds double, double* %0, i64 %54
%56 = bitcast double* %55 to <2 x double>*
%57 = load <2 x double>, <2 x double>* %56
%58 = getelementptr inbounds double, double* %55, i64 2
%59 = bitcast double* %58 to <2 x double>*
%60 = load <2 x double>, <2 x double>* %59
%61 = getelementptr inbounds double, double* %10, i64 %54
%62 = bitcast double* %61 to <2 x double>*
store <2 x double> %57, <2 x double>* %62
%63 = getelementptr inbounds double, double* %61, i64 2
%64 = bitcast double* %63 to <2 x double>*
store <2 x double> %60, <2 x double>* %64
%65 = or i64 %31, 12
%66 = getelementptr inbounds double, double* %0, i64 %65
%67 = bitcast double* %66 to <2 x double>*
%68 = load <2 x double>, <2 x double>* %67
%69 = getelementptr inbounds double, double* %66, i64 2
%70 = bitcast double* %69 to <2 x double>*
%71 = load <2 x double>, <2 x double>* %70
%72 = getelementptr inbounds double, double* %10, i64 %65
%73 = bitcast double* %72 to <2 x double>*
store <2 x double> %68, <2 x double>* %73
%74 = getelementptr inbounds double, double* %72, i64 2
%75 = bitcast double* %74 to <2 x double>*
store <2 x double> %71, <2 x double>* %75
%76 = add nuw i64 %31, 16
%77 = add nuw i64 %32, 4
%78 = icmp eq i64 %77, %29
br i1 %78, label %79, label %30
79: ; preds = %30, %21
%80 = phi i64 [ 0, %21 ], [ %76, %30 ]
%81 = icmp eq i64 %26, 0
br i1 %81, label %98, label %82
82: ; preds = %79, %82
%83 = phi i64 [ %95, %82 ], [ %80, %79 ]
%84 = phi i64 [ %96, %82 ], [ 0, %79 ]
%85 = getelementptr inbounds double, double* %0, i64 %83
%86 = bitcast double* %85 to <2 x double>*
%87 = load <2 x double>, <2 x double>* %86
%88 = getelementptr inbounds double, double* %85, i64 2
%89 = bitcast double* %88 to <2 x double>*
%90 = load <2 x double>, <2 x double>* %89
%91 = getelementptr inbounds double, double* %10, i64 %83
%92 = bitcast double* %91 to <2 x double>*
store <2 x double> %87, <2 x double>* %92
%93 = getelementptr inbounds double, double* %91, i64 2
%94 = bitcast double* %93 to <2 x double>*
store <2 x double> %90, <2 x double>* %94
%95 = add nuw i64 %83, 4
%96 = add i64 %84, 1
%97 = icmp eq i64 %96, %26
br i1 %97, label %98, label %82
98: ; preds = %82, %79
%99 = icmp eq i64 %22, %13
br i1 %99, label %118, label %100
100: ; preds = %15, %12, %98
%101 = phi i64 [ 0, %15 ], [ 0, %12 ], [ %22, %98 ]
%102 = xor i64 %101, -1
%103 = add nsw i64 %102, %13
%104 = and i64 %13, 3
%105 = icmp eq i64 %104, 0
br i1 %105, label %115, label %106
106: ; preds = %100, %106
%107 = phi i64 [ %112, %106 ], [ %101, %100 ]
%108 = phi i64 [ %113, %106 ], [ 0, %100 ]
%109 = getelementptr inbounds double, double* %0, i64 %107
%110 = load double, double* %109
%111 = getelementptr inbounds double, double* %10, i64 %107
store double %110, double* %111
%112 = add nuw nsw i64 %107, 1
%113 = add i64 %108, 1
%114 = icmp eq i64 %113, %104
br i1 %114, label %115, label %106
115: ; preds = %106, %100
%116 = phi i64 [ %101, %100 ], [ %112, %106 ]
%117 = icmp ult i64 %103, 3
br i1 %117, label %118, label %129
118: ; preds = %115, %129, %98, %2
%119 = call i32 @bin_equnumber(double* %10, i32 %1, i32 %8, double** %3, double** %4)
%120 = icmp sgt i32 %8, 0
br i1 %120, label %121, label %170
121: ; preds = %118
%122 = load double*, double** %4
%123 = zext i32 %8 to i64
%124 = add nsw i64 %123, -1
%125 = and i64 %123, 3
%126 = icmp ult i64 %124, 3
br i1 %126, label %148, label %127
127: ; preds = %121
%128 = and i64 %123, 4294967292
br label %176
129: ; preds = %115, %129
%130 = phi i64 [ %146, %129 ], [ %116, %115 ]
%131 = getelementptr inbounds double, double* %0, i64 %130
%132 = load double, double* %131
%133 = getelementptr inbounds double, double* %10, i64 %130
store double %132, double* %133
%134 = add nuw nsw i64 %130, 1
%135 = getelementptr inbounds double, double* %0, i64 %134
%136 = load double, double* %135
%137 = getelementptr inbounds double, double* %10, i64 %134
store double %136, double* %137
%138 = add nuw nsw i64 %130, 2
%139 = getelementptr inbounds double, double* %0, i64 %138
%140 = load double, double* %139
%141 = getelementptr inbounds double, double* %10, i64 %138
store double %140, double* %141
%142 = add nuw nsw i64 %130, 3
%143 = getelementptr inbounds double, double* %0, i64 %142
%144 = load double, double* %143
%145 = getelementptr inbounds double, double* %10, i64 %142
store double %144, double* %145
%146 = add nuw nsw i64 %130, 4
%147 = icmp eq i64 %146, %13
br i1 %147, label %118, label %129
148: ; preds = %176, %121
%149 = phi i64 [ 0, %121 ], [ %208, %176 ]
%150 = phi i32 [ undef, %121 ], [ %207, %176 ]
%151 = phi double [ 0.000000e+00, %121 ], [ %205, %176 ]
%152 = icmp eq i64 %125, 0
br i1 %152, label %167, label %153
153: ; preds = %148, %153
%154 = phi i64 [ %164, %153 ], [ %149, %148 ]
%155 = phi i32 [ %163, %153 ], [ %150, %148 ]
%156 = phi double [ %161, %153 ], [ %151, %148 ]
%157 = phi i64 [ %165, %153 ], [ 0, %148 ]
%158 = getelementptr inbounds double, double* %122, i64 %154
%159 = load double, double* %158
%160 = fcmp ugt double %156, %159
%161 = select i1 %160, double %156, double %159
%162 = trunc i64 %154 to i32
%163 = select i1 %160, i32 %155, i32 %162
%164 = add nuw nsw i64 %154, 1
%165 = add i64 %157, 1
%166 = icmp eq i64 %165, %125
br i1 %166, label %167, label %153
167: ; preds = %153, %148
%168 = phi i32 [ %150, %148 ], [ %163, %153 ]
%169 = sext i32 %168 to i64
br label %170
170: ; preds = %167, %118
%171 = phi i64 [ 0, %118 ], [ %169, %167 ]
%172 = call i32 @free_darray(double* %10, i32 0, i32 %1)
%173 = load double*, double** %3
%174 = getelementptr inbounds double, double* %173, i64 %171
%175 = load double, double* %174
ret double %175
176: ; preds = %176, %127
%177 = phi i64 [ 0, %127 ], [ %208, %176 ]
%178 = phi i32 [ undef, %127 ], [ %207, %176 ]
%179 = phi double [ 0.000000e+00, %127 ], [ %205, %176 ]
%180 = phi i64 [ 0, %127 ], [ %209, %176 ]
%181 = getelementptr inbounds double, double* %122, i64 %177
%182 = load double, double* %181
%183 = fcmp ugt double %179, %182
%184 = select i1 %183, double %179, double %182
%185 = trunc i64 %177 to i32
%186 = select i1 %183, i32 %178, i32 %185
%187 = or i64 %177, 1
%188 = getelementptr inbounds double, double* %122, i64 %187
%189 = load double, double* %188
%190 = fcmp ugt double %184, %189
%191 = select i1 %190, double %184, double %189
%192 = trunc i64 %187 to i32
%193 = select i1 %190, i32 %186, i32 %192
%194 = or i64 %177, 2
%195 = getelementptr inbounds double, double* %122, i64 %194
%196 = load double, double* %195
%197 = fcmp ugt double %191, %196
%198 = select i1 %197, double %191, double %196
%199 = trunc i64 %194 to i32
%200 = select i1 %197, i32 %193, i32 %199
%201 = or i64 %177, 3
%202 = getelementptr inbounds double, double* %122, i64 %201
%203 = load double, double* %202
%204 = fcmp ugt double %198, %203
%205 = select i1 %204, double %198, double %203
%206 = trunc i64 %201 to i32
%207 = select i1 %204, i32 %200, i32 %206
%208 = add nuw nsw i64 %177, 4
%209 = add i64 %180, 4
%210 = icmp eq i64 %209, %128
br i1 %210, label %148, label %176
}