#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 */
double *calloc(int, int);
int /*<<< orphan*/ free(double *);
void getqval(double *Proba, double *qval, int nSNP, int K) {
  int i, snp, imin = 0;
  double q = 0;
  double *Pz = calloc(nSNP, sizeof(double));
  for (i = 0; i < nSNP; i++)
    Pz[i] = Proba[i * (K + 1)];
  for (snp = 0; snp < nSNP; snp++) {
    for (i = 0; i < nSNP; i++) {
      if (Pz[i] < Pz[imin])
        imin = i;
    }
    q = (q * snp + Pz[imin]) / (snp + 1);
    qval[imin] = q;
    Pz[imin] = 12;
  }
  free(Pz);
}


x86 assembly (clang, -O0):
<getqval>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movl   $0x0,-0x24(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x14(%rbp),%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    119c <getqval+0x7c>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    115d <getqval+0x3d>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1266 <getqval+0x146>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11ff <getqval+0xdf>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    11ec <getqval+0xcc>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    11f1 <getqval+0xd1>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11b6 <getqval+0x96>
movsd  -0x30(%rbp),%xmm0
cvtsi2sdl -0x20(%rbp),%xmm2
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  0xdad(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11a3 <getqval+0x83>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getqval>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %ecx,%ebp
mov    %edx,%r12d
mov    %rsi,%r14
mov    %rdi,%r15
mov    %edx,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
test   %r12d,%r12d
jle    1309 <getqval+0x1e9>
add    $0x1,%ebp
movslq %ebp,%rdx
mov    %r12d,%ecx
lea    -0x1(%rcx),%r9
mov    %ecx,%r8d
and    $0x3,%r8d
cmp    $0x3,%r9
jae    1166 <getqval+0x46>
xor    %edi,%edi
jmp    11c7 <getqval+0xa7>
mov    %ecx,%r10d
and    $0xfffffffc,%r10d
mov    %rdx,%r11
shl    $0x4,%r11
mov    %rdx,%rsi
shl    $0x5,%rsi
lea    0x0(,%rdx,8),%rdi
lea    (%rdi,%rdi,2),%rbp
xor    %edi,%edi
mov    %r15,%rbx
nopl   0x0(%rax)
movsd  (%rbx),%xmm0
movsd  %xmm0,(%rax,%rdi,8)
movsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rdi,8)
movsd  (%rbx,%r11,1),%xmm0
movsd  %xmm0,0x10(%rax,%rdi,8)
movsd  (%rbx,%rbp,1),%xmm0
movsd  %xmm0,0x18(%rax,%rdi,8)
add    $0x4,%rdi
add    %rsi,%rbx
cmp    %rdi,%r10
jne    1190 <getqval+0x70>
test   %r8,%r8
je     11f5 <getqval+0xd5>
lea    (%rax,%rdi,8),%rsi
imul   %rdx,%rdi
lea    (%r15,%rdi,8),%rdi
shl    $0x3,%rdx
xor    %ebp,%ebp
xchg   %ax,%ax
movsd  (%rdi),%xmm0
movsd  %xmm0,(%rsi,%rbp,8)
add    $0x1,%rbp
add    %rdx,%rdi
cmp    %rbp,%r8
jne    11e0 <getqval+0xc0>
test   %r12d,%r12d
jle    1309 <getqval+0x1e9>
mov    %ecx,%r10d
and    $0x3,%r10d
and    $0xfffffffc,%ecx
xor    %edx,%edx
xorpd  %xmm0,%xmm0
movsd  0xdea(%rip),%xmm1
movabs $0x4028000000000000,%r8
xorpd  %xmm2,%xmm2
xor    %ebp,%ebp
jmp    1263 <getqval+0x143>
nopl   0x0(%rax,%rax,1)
movslq %ebx,%rdx
mulsd  %xmm2,%xmm0
addsd  (%rax,%rdx,8),%xmm0
addsd  %xmm1,%xmm2
add    $0x1,%ebp
xorps  %xmm3,%xmm3
cvtsi2sd %ebp,%xmm3
divsd  %xmm3,%xmm0
movsd  %xmm0,(%r14,%rdx,8)
mov    %r8,(%rax,%rdx,8)
mov    %ebx,%edx
cmp    %r12d,%ebp
je     1309 <getqval+0x1e9>
xor    %edi,%edi
cmp    $0x3,%r9
jae    12bb <getqval+0x19b>
mov    %edx,%ebx
test   %r10,%r10
je     1230 <getqval+0x110>
mov    %r10,%rsi
jmp    128c <getqval+0x16c>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdi
mov    %ebx,%edx
add    $0xffffffffffffffff,%rsi
je     1230 <getqval+0x110>
movslq %edx,%rbx
movsd  (%rax,%rbx,8),%xmm3
ucomisd (%rax,%rdi,8),%xmm3
mov    %edi,%ebx
ja     1280 <getqval+0x160>
mov    %edx,%ebx
jmp    1280 <getqval+0x160>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ebx,%edx
add    $0x4,%rdi
cmp    %rcx,%rdi
je     126b <getqval+0x14b>
movslq %edx,%rsi
movsd  (%rax,%rsi,8),%xmm3
ucomisd (%rax,%rdi,8),%xmm3
mov    %edi,%ebx
ja     12ce <getqval+0x1ae>
mov    %edx,%ebx
movslq %ebx,%rdx
movsd  (%rax,%rdx,8),%xmm3
ucomisd 0x8(%rax,%rdi,8),%xmm3
jbe    12e1 <getqval+0x1c1>
lea    0x1(%rdi),%ebx
movslq %ebx,%rdx
movsd  (%rax,%rdx,8),%xmm3
ucomisd 0x10(%rax,%rdi,8),%xmm3
jbe    12f4 <getqval+0x1d4>
lea    0x2(%rdi),%ebx
movslq %ebx,%rdx
movsd  (%rax,%rdx,8),%xmm3
ucomisd 0x18(%rax,%rdi,8),%xmm3
jbe    12b0 <getqval+0x190>
lea    0x3(%rdi),%edx
jmp    12b2 <getqval+0x192>
mov    %rax,%rdi
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

LLVM IR (-O0):
define void @getqval(double* %0, double* %1, i32 %2, i32 %3) {
%5 = alloca double*
%6 = alloca double*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca double
%13 = alloca double*
store double* %0, double** %5
store double* %1, double** %6
store i32 %2, i32* %7
store i32 %3, i32* %8
store i32 0, i32* %11
store double 0.000000e+00, double* %12
%14 = load i32, i32* %7
%15 = call double* @calloc(i32 %14, i32 8)
store double* %15, double** %13
store i32 0, i32* %9
br label %16
16: ; preds = %33, %4
%17 = load i32, i32* %9
%18 = load i32, i32* %7
%19 = icmp slt i32 %17, %18
br i1 %19, label %20, label %36
20: ; preds = %16
%21 = load double*, double** %5
%22 = load i32, i32* %9
%23 = load i32, i32* %8
%24 = add nsw i32 %23, 1
%25 = mul nsw i32 %22, %24
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds double, double* %21, i64 %26
%28 = load double, double* %27
%29 = load double*, double** %13
%30 = load i32, i32* %9
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds double, double* %29, i64 %31
store double %28, double* %32
br label %33
33: ; preds = %20
%34 = load i32, i32* %9
%35 = add nsw i32 %34, 1
store i32 %35, i32* %9
br label %16
36: ; preds = %16
store i32 0, i32* %10
br label %37
37: ; preds = %87, %36
%38 = load i32, i32* %10
%39 = load i32, i32* %7
%40 = icmp slt i32 %38, %39
br i1 %40, label %41, label %90
41: ; preds = %37
store i32 0, i32* %9
br label %42
42: ; preds = %61, %41
%43 = load i32, i32* %9
%44 = load i32, i32* %7
%45 = icmp slt i32 %43, %44
br i1 %45, label %46, label %64
46: ; preds = %42
%47 = load double*, double** %13
%48 = load i32, i32* %9
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds double, double* %47, i64 %49
%51 = load double, double* %50
%52 = load double*, double** %13
%53 = load i32, i32* %11
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds double, double* %52, i64 %54
%56 = load double, double* %55
%57 = fcmp olt double %51, %56
br i1 %57, label %58, label %60
58: ; preds = %46
%59 = load i32, i32* %9
store i32 %59, i32* %11
br label %60
60: ; preds = %58, %46
br label %61
61: ; preds = %60
%62 = load i32, i32* %9
%63 = add nsw i32 %62, 1
store i32 %63, i32* %9
br label %42
64: ; preds = %42
%65 = load double, double* %12
%66 = load i32, i32* %10
%67 = sitofp i32 %66 to double
%68 = load double*, double** %13
%69 = load i32, i32* %11
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds double, double* %68, i64 %70
%72 = load double, double* %71
%73 = call double @llvm.fmuladd.f64(double %65, double %67, double %72)
%74 = load i32, i32* %10
%75 = add nsw i32 %74, 1
%76 = sitofp i32 %75 to double
%77 = fdiv double %73, %76
store double %77, double* %12
%78 = load double, double* %12
%79 = load double*, double** %6
%80 = load i32, i32* %11
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds double, double* %79, i64 %81
store double %78, double* %82
%83 = load double*, double** %13
%84 = load i32, i32* %11
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds double, double* %83, i64 %85
store double 1.200000e+01, double* %86
br label %87
87: ; preds = %64
%88 = load i32, i32* %10
%89 = add nsw i32 %88, 1
store i32 %89, i32* %10
br label %37
90: ; preds = %37
%91 = load double*, double** %13
%92 = call i32 @free(double* %91)
ret void
}

LLVM IR (-O2):
define void @getqval(double* nocapture %0, double* nocapture writeonly %1, i32 %2, i32 %3) {
%5 = tail call double* @calloc(i32 %2, i32 8)
%6 = icmp sgt i32 %2, 0
br i1 %6, label %7, label %138
7: ; preds = %4
%8 = add nsw i32 %3, 1
%9 = sext i32 %8 to i64
%10 = zext i32 %2 to i64
%11 = add nsw i64 %10, -1
%12 = and i64 %10, 3
%13 = icmp ult i64 %11, 3
br i1 %13, label %16, label %14
14: ; preds = %7
%15 = and i64 %10, 4294967292
br label %36
16: ; preds = %36, %7
%17 = phi i64 [ 0, %7 ], [ %58, %36 ]
%18 = icmp eq i64 %12, 0
br i1 %18, label %29, label %19
19: ; preds = %16, %19
%20 = phi i64 [ %26, %19 ], [ %17, %16 ]
%21 = phi i64 [ %27, %19 ], [ 0, %16 ]
%22 = mul nsw i64 %20, %9
%23 = getelementptr inbounds double, double* %0, i64 %22
%24 = load double, double* %23
%25 = getelementptr inbounds double, double* %5, i64 %20
store double %24, double* %25
%26 = add nuw nsw i64 %20, 1
%27 = add i64 %21, 1
%28 = icmp eq i64 %27, %12
br i1 %28, label %29, label %19
29: ; preds = %19, %16
br i1 %6, label %30, label %138
30: ; preds = %29
%31 = zext i32 %2 to i64
%32 = and i64 %31, 3
%33 = icmp ult i64 %11, 3
%34 = and i64 %31, 4294967292
%35 = icmp eq i64 %32, 0
br label %61
36: ; preds = %36, %14
%37 = phi i64 [ 0, %14 ], [ %58, %36 ]
%38 = phi i64 [ 0, %14 ], [ %59, %36 ]
%39 = mul nsw i64 %37, %9
%40 = getelementptr inbounds double, double* %0, i64 %39
%41 = load double, double* %40
%42 = getelementptr inbounds double, double* %5, i64 %37
store double %41, double* %42
%43 = or i64 %37, 1
%44 = mul nsw i64 %43, %9
%45 = getelementptr inbounds double, double* %0, i64 %44
%46 = load double, double* %45
%47 = getelementptr inbounds double, double* %5, i64 %43
store double %46, double* %47
%48 = or i64 %37, 2
%49 = mul nsw i64 %48, %9
%50 = getelementptr inbounds double, double* %0, i64 %49
%51 = load double, double* %50
%52 = getelementptr inbounds double, double* %5, i64 %48
store double %51, double* %52
%53 = or i64 %37, 3
%54 = mul nsw i64 %53, %9
%55 = getelementptr inbounds double, double* %0, i64 %54
%56 = load double, double* %55
%57 = getelementptr inbounds double, double* %5, i64 %53
store double %56, double* %57
%58 = add nuw nsw i64 %37, 4
%59 = add i64 %38, 4
%60 = icmp eq i64 %59, %15
br i1 %60, label %16, label %36
61: ; preds = %126, %30
%62 = phi double [ 0.000000e+00, %30 ], [ %135, %126 ]
%63 = phi i32 [ 0, %30 ], [ %127, %126 ]
%64 = phi i32 [ 0, %30 ], [ %133, %126 ]
br i1 %33, label %107, label %65
65: ; preds = %61, %65
%66 = phi i64 [ %104, %65 ], [ 0, %61 ]
%67 = phi i32 [ %103, %65 ], [ %63, %61 ]
%68 = phi i64 [ %105, %65 ], [ 0, %61 ]
%69 = getelementptr inbounds double, double* %5, i64 %66
%70 = load double, double* %69
%71 = sext i32 %67 to i64
%72 = getelementptr inbounds double, double* %5, i64 %71
%73 = load double, double* %72
%74 = fcmp olt double %70, %73
%75 = trunc i64 %66 to i32
%76 = select i1 %74, i32 %75, i32 %67
%77 = or i64 %66, 1
%78 = getelementptr inbounds double, double* %5, i64 %77
%79 = load double, double* %78
%80 = sext i32 %76 to i64
%81 = getelementptr inbounds double, double* %5, i64 %80
%82 = load double, double* %81
%83 = fcmp olt double %79, %82
%84 = trunc i64 %77 to i32
%85 = select i1 %83, i32 %84, i32 %76
%86 = or i64 %66, 2
%87 = getelementptr inbounds double, double* %5, i64 %86
%88 = load double, double* %87
%89 = sext i32 %85 to i64
%90 = getelementptr inbounds double, double* %5, i64 %89
%91 = load double, double* %90
%92 = fcmp olt double %88, %91
%93 = trunc i64 %86 to i32
%94 = select i1 %92, i32 %93, i32 %85
%95 = or i64 %66, 3
%96 = getelementptr inbounds double, double* %5, i64 %95
%97 = load double, double* %96
%98 = sext i32 %94 to i64
%99 = getelementptr inbounds double, double* %5, i64 %98
%100 = load double, double* %99
%101 = fcmp olt double %97, %100
%102 = trunc i64 %95 to i32
%103 = select i1 %101, i32 %102, i32 %94
%104 = add nuw nsw i64 %66, 4
%105 = add i64 %68, 4
%106 = icmp eq i64 %105, %34
br i1 %106, label %107, label %65
107: ; preds = %65, %61
%108 = phi i32 [ undef, %61 ], [ %103, %65 ]
%109 = phi i64 [ 0, %61 ], [ %104, %65 ]
%110 = phi i32 [ %63, %61 ], [ %103, %65 ]
br i1 %35, label %126, label %111
111: ; preds = %107, %111
%112 = phi i64 [ %123, %111 ], [ %109, %107 ]
%113 = phi i32 [ %122, %111 ], [ %110, %107 ]
%114 = phi i64 [ %124, %111 ], [ 0, %107 ]
%115 = getelementptr inbounds double, double* %5, i64 %112
%116 = load double, double* %115
%117 = sext i32 %113 to i64
%118 = getelementptr inbounds double, double* %5, i64 %117
%119 = load double, double* %118
%120 = fcmp olt double %116, %119
%121 = trunc i64 %112 to i32
%122 = select i1 %120, i32 %121, i32 %113
%123 = add nuw nsw i64 %112, 1
%124 = add i64 %114, 1
%125 = icmp eq i64 %124, %32
br i1 %125, label %126, label %111
126: ; preds = %111, %107
%127 = phi i32 [ %108, %107 ], [ %122, %111 ]
%128 = sitofp i32 %64 to double
%129 = sext i32 %127 to i64
%130 = getelementptr inbounds double, double* %5, i64 %129
%131 = load double, double* %130
%132 = tail call double @llvm.fmuladd.f64(double %62, double %128, double %131)
%133 = add nuw nsw i32 %64, 1
%134 = sitofp i32 %133 to double
%135 = fdiv double %132, %134
%136 = getelementptr inbounds double, double* %1, i64 %129
store double %135, double* %136
store double 1.200000e+01, double* %130
%137 = icmp eq i32 %133, %2
br i1 %137, label %138, label %61
138: ; preds = %126, %4, %29
%139 = tail call i32 @free(double* %5)
ret void
}