#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 *allocate_vector(int /*<<< orphan*/, int);
int /*<<< orphan*/ free(double *);
double log10(double);
double f8_sentropy(double **P, int Ng) {
  int i, j;
  double sentropy = 0;
  double *Pxpy = allocate_vector(0, 2 * Ng);
  for (i = 0; i <= 2 * Ng; ++i)
    Pxpy[i] = 0;
  for (i = 0; i < Ng; ++i)
    for (j = 0; j < Ng; ++j)
      Pxpy[i + j + 2] += P[i][j];
  for (i = 2; i <= 2 * Ng; ++i)
    sentropy -= Pxpy[i] * log10(Pxpy[i] + 0.000000001) / log10(2.0);
  free(Pxpy);
  return sentropy;
}


x86 assembly (clang, -O0):
<f8_sentropy>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0xc(%rbp),%esi
shl    $0x1,%esi
xor    %edi,%edi
call   1040 <allocate_vector@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jg     118e <f8_sentropy+0x5e>
mov    -0x28(%rbp),%rax
movslq -0x10(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    115f <f8_sentropy+0x2f>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1204 <f8_sentropy+0xd4>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11f1 <f8_sentropy+0xc1>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11a8 <f8_sentropy+0x78>
jmp    11f6 <f8_sentropy+0xc6>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1195 <f8_sentropy+0x65>
movl   $0x2,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jg     128b <f8_sentropy+0x15b>
mov    -0x28(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  0xdca(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
call   1050 <log10@plt>
movaps %xmm0,%xmm1
movsd  -0x38(%rbp),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0xd9f(%rip),%xmm0
call   1050 <log10@plt>
movsd  -0x30(%rbp),%xmm1
divsd  %xmm0,%xmm1
movsd  -0x20(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    120b <f8_sentropy+0xdb>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
movsd  -0x20(%rbp),%xmm0
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<f8_sentropy>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %esi,%r12d
mov    %rdi,%r15
lea    (%r12,%r12,1),%ebx
xor    %ebp,%ebp
xor    %edi,%edi
mov    %ebx,%esi
call   1050 <allocate_vector@plt>
mov    %rax,%r13
test   %r12d,%r12d
js     1373 <f8_sentropy+0x233>
test   %ebx,%ebx
cmovg  %ebx,%ebp
shl    $0x3,%rbp
or     $0x8,%rbp
mov    %r13,%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1040 <memset@plt>
test   %r12d,%r12d
je     1373 <f8_sentropy+0x233>
mov    %ebx,0x14(%rsp)
mov    %r12d,%eax
lea    0x2(%rax),%rcx
mov    %rcx,(%rsp)
mov    %eax,%r11d
and    $0xfffffffc,%r11d
lea    -0x4(%r11),%rcx
mov    %rcx,0x8(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %rdx,%rcx
mov    %rdx,0x20(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x18(%rsp)
mov    %rax,%r10
neg    %r10
lea    0x40(%r13),%rsi
lea    0x18(%r13),%rcx
xor    %edi,%edi
jmp    11f5 <f8_sentropy+0xb5>
nop
add    $0x1,%rdi
add    $0x8,%rsi
add    $0x8,%rcx
cmp    %rax,%rdi
je     137c <f8_sentropy+0x23c>
lea    0x2(%rdi),%r14
mov    (%r15,%rdi,8),%rdx
cmp    $0x4,%r12d
jb     122e <f8_sentropy+0xee>
lea    0x10(,%rdi,8),%rbp
add    %r13,%rbp
lea    (%rdx,%rax,8),%rbx
cmp    %rbx,%rbp
jae    1290 <f8_sentropy+0x150>
mov    (%rsp),%rbp
add    %rdi,%rbp
lea    0x0(,%rbp,8),%rbp
add    %r13,%rbp
cmp    %rbp,%rdx
jae    1290 <f8_sentropy+0x150>
xor    %ebx,%ebx
mov    %rbx,%rbp
test   $0x1,%al
je     1254 <f8_sentropy+0x114>
movsd  (%rdx,%rbx,8),%xmm0
add    %rbx,%r14
addsd  0x0(%r13,%r14,8),%xmm0
movsd  %xmm0,0x0(%r13,%r14,8)
mov    %rbx,%rbp
or     $0x1,%rbp
not    %rbx
cmp    %r10,%rbx
je     11e0 <f8_sentropy+0xa0>
nopl   0x0(%rax)
movsd  (%rdx,%rbp,8),%xmm0
addsd  -0x8(%rcx,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rbp,8)
movsd  0x8(%rdx,%rbp,8),%xmm0
addsd  (%rcx,%rbp,8),%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%rax
jne    1260 <f8_sentropy+0x120>
jmp    11e0 <f8_sentropy+0xa0>
nop
cmpq   $0x0,0x8(%rsp)
je     1367 <f8_sentropy+0x227>
mov    0x18(%rsp),%r9
xor    %r8d,%r8d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%rdx,%r8,8),%xmm0
movupd 0x10(%rdx,%r8,8),%xmm1
movupd -0x30(%rsi,%r8,8),%xmm2
addpd  %xmm0,%xmm2
movupd -0x20(%rsi,%r8,8),%xmm0
addpd  %xmm1,%xmm0
movupd -0x10(%rsi,%r8,8),%xmm1
movupd (%rsi,%r8,8),%xmm3
movupd %xmm2,-0x30(%rsi,%r8,8)
movupd %xmm0,-0x20(%rsi,%r8,8)
movupd 0x20(%rdx,%r8,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x30(%rdx,%r8,8),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,-0x10(%rsi,%r8,8)
movupd %xmm1,(%rsi,%r8,8)
add    $0x8,%r8
add    $0xfffffffffffffffe,%r9
jne    12b0 <f8_sentropy+0x170>
testb  $0x1,0x20(%rsp)
je     1356 <f8_sentropy+0x216>
movupd (%rdx,%r8,8),%xmm0
movupd 0x10(%rdx,%r8,8),%xmm1
add    %r14,%r8
movupd 0x0(%r13,%r8,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r13,%r8,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,0x0(%r13,%r8,8)
movupd %xmm0,0x10(%r13,%r8,8)
mov    %r11,%rbx
cmp    %rax,%r11
je     11e0 <f8_sentropy+0xa0>
jmp    1230 <f8_sentropy+0xf0>
xor    %r8d,%r8d
testb  $0x1,0x20(%rsp)
jne    1322 <f8_sentropy+0x1e2>
jmp    1356 <f8_sentropy+0x216>
xorpd  %xmm0,%xmm0
jmp    13f9 <f8_sentropy+0x2b9>
test   %r12d,%r12d
xorpd  %xmm0,%xmm0
jle    13f9 <f8_sentropy+0x2b9>
mov    0x14(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%r14d
cmovge %eax,%r14d
or     $0x1,%r14d
add    $0xfffffffffffffffe,%r14
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  %xmm0,(%rsp)
movsd  0x10(%r13,%rbp,8),%xmm0
movsd  %xmm0,0x8(%rsp)
addsd  0xc36(%rip),%xmm0
call   1060 <log10@plt>
mulsd  0x8(%rsp),%xmm0
divsd  0xc2b(%rip),%xmm0
movsd  (%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
movsd  (%rsp),%xmm0
add    $0x1,%rbp
cmp    %rbp,%r14
jne    13b0 <f8_sentropy+0x270>
movsd  %xmm0,(%rsp)
mov    %r13,%rdi
call   1030 <free@plt>
movsd  (%rsp),%xmm0
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define double @f8_sentropy(double** nocapture %0, i32 %1) {
%3 = shl nsw i32 %1, 1
%4 = tail call double* @allocate_vector(i32 0, i32 %3)
%5 = icmp slt i32 %1, 0
br i1 %5, label %159, label %6
6: ; preds = %2
%7 = bitcast double* %4 to i8*
%8 = call i32 @llvm.smax.i32(i32 %3, i32 0)
%9 = zext i32 %8 to i64
%10 = shl nuw nsw i64 %9, 3
%11 = or i64 %10, 8
%12 = icmp eq i32 %1, 0
br i1 %12, label %159, label %13
13: ; preds = %6
%14 = zext i32 %1 to i64
%15 = add nuw nsw i64 %14, 2
%16 = and i64 %14, 4294967292
%17 = add nsw i64 %16, -4
%18 = lshr exact i64 %17, 2
%19 = add nuw nsw i64 %18, 1
%20 = icmp ult i32 %1, 4
%21 = and i64 %14, 4294967292
%22 = and i64 %19, 1
%23 = icmp eq i64 %17, 0
%24 = and i64 %19, 9223372036854775806
%25 = icmp eq i64 %22, 0
%26 = icmp eq i64 %21, %14
%27 = and i64 %14, 1
%28 = icmp eq i64 %27, 0
%29 = sub nsw i64 0, %14
br label %30
30: ; preds = %144, %13
%31 = phi i64 [ 0, %13 ], [ %145, %144 ]
%32 = getelementptr inbounds double*, double** %0, i64 %31
%33 = load double*, double** %32
%34 = add nuw nsw i64 %31, 2
br i1 %20, label %107, label %35
35: ; preds = %30
%36 = add nuw i64 %15, %31
%37 = getelementptr double, double* %4, i64 %36
%38 = add nuw i64 %31, 2
%39 = getelementptr double, double* %4, i64 %38
%40 = getelementptr double, double* %33, i64 %14
%41 = icmp ult double* %39, %40
%42 = icmp ult double* %33, %37
%43 = and i1 %41, %42
br i1 %43, label %107, label %44
44: ; preds = %35
br i1 %23, label %86, label %45
45: ; preds = %44, %45
%46 = phi i64 [ %83, %45 ], [ 0, %44 ]
%47 = phi i64 [ %84, %45 ], [ 0, %44 ]
%48 = getelementptr inbounds double, double* %33, i64 %46
%49 = bitcast double* %48 to <2 x double>*
%50 = load <2 x double>, <2 x double>* %49
%51 = getelementptr inbounds double, double* %48, i64 2
%52 = bitcast double* %51 to <2 x double>*
%53 = load <2 x double>, <2 x double>* %52
%54 = add nuw nsw i64 %34, %46
%55 = getelementptr inbounds double, double* %4, 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 = fadd <2 x double> %50, %57
%62 = fadd <2 x double> %53, %60
%63 = bitcast double* %55 to <2 x double>*
store <2 x double> %61, <2 x double>* %63
%64 = bitcast double* %58 to <2 x double>*
store <2 x double> %62, <2 x double>* %64
%65 = or i64 %46, 4
%66 = getelementptr inbounds double, double* %33, 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 = add nuw nsw i64 %34, %65
%73 = getelementptr inbounds double, double* %4, i64 %72
%74 = bitcast double* %73 to <2 x double>*
%75 = load <2 x double>, <2 x double>* %74
%76 = getelementptr inbounds double, double* %73, i64 2
%77 = bitcast double* %76 to <2 x double>*
%78 = load <2 x double>, <2 x double>* %77
%79 = fadd <2 x double> %68, %75
%80 = fadd <2 x double> %71, %78
%81 = bitcast double* %73 to <2 x double>*
store <2 x double> %79, <2 x double>* %81
%82 = bitcast double* %76 to <2 x double>*
store <2 x double> %80, <2 x double>* %82
%83 = add nuw i64 %46, 8
%84 = add i64 %47, 2
%85 = icmp eq i64 %84, %24
br i1 %85, label %86, label %45
86: ; preds = %45, %44
%87 = phi i64 [ 0, %44 ], [ %83, %45 ]
br i1 %25, label %106, label %88
88: ; preds = %86
%89 = getelementptr inbounds double, double* %33, i64 %87
%90 = bitcast double* %89 to <2 x double>*
%91 = load <2 x double>, <2 x double>* %90
%92 = getelementptr inbounds double, double* %89, i64 2
%93 = bitcast double* %92 to <2 x double>*
%94 = load <2 x double>, <2 x double>* %93
%95 = add nuw nsw i64 %34, %87
%96 = getelementptr inbounds double, double* %4, i64 %95
%97 = bitcast double* %96 to <2 x double>*
%98 = load <2 x double>, <2 x double>* %97
%99 = getelementptr inbounds double, double* %96, i64 2
%100 = bitcast double* %99 to <2 x double>*
%101 = load <2 x double>, <2 x double>* %100
%102 = fadd <2 x double> %91, %98
%103 = fadd <2 x double> %94, %101
%104 = bitcast double* %96 to <2 x double>*
store <2 x double> %102, <2 x double>* %104
%105 = bitcast double* %99 to <2 x double>*
store <2 x double> %103, <2 x double>* %105
br label %106
106: ; preds = %86, %88
br i1 %26, label %144, label %107
107: ; preds = %35, %30, %106
%108 = phi i64 [ 0, %35 ], [ 0, %30 ], [ %21, %106 ]
%109 = xor i64 %108, -1
br i1 %28, label %118, label %110
110: ; preds = %107
%111 = getelementptr inbounds double, double* %33, i64 %108
%112 = load double, double* %111
%113 = add nuw nsw i64 %34, %108
%114 = getelementptr inbounds double, double* %4, i64 %113
%115 = load double, double* %114
%116 = fadd double %112, %115
store double %116, double* %114
%117 = or i64 %108, 1
br label %118
118: ; preds = %110, %107
%119 = phi i64 [ %108, %107 ], [ %117, %110 ]
%120 = icmp eq i64 %109, %29
br i1 %120, label %144, label %127
121: ; preds = %144
%122 = icmp slt i32 %1, 1
br i1 %122, label %159, label %123
123: ; preds = %121
%124 = call i32 @llvm.smax.i32(i32 %3, i32 2)
%125 = or i32 %124, 1
%126 = zext i32 %125 to i64
br label %147
127: ; preds = %118, %127
%128 = phi i64 [ %142, %127 ], [ %119, %118 ]
%129 = getelementptr inbounds double, double* %33, i64 %128
%130 = load double, double* %129
%131 = add nuw nsw i64 %34, %128
%132 = getelementptr inbounds double, double* %4, i64 %131
%133 = load double, double* %132
%134 = fadd double %130, %133
store double %134, double* %132
%135 = add nuw nsw i64 %128, 1
%136 = getelementptr inbounds double, double* %33, i64 %135
%137 = load double, double* %136
%138 = add nuw nsw i64 %34, %135
%139 = getelementptr inbounds double, double* %4, i64 %138
%140 = load double, double* %139
%141 = fadd double %137, %140
store double %141, double* %139
%142 = add nuw nsw i64 %128, 2
%143 = icmp eq i64 %142, %14
br i1 %143, label %144, label %127
144: ; preds = %118, %127, %106
%145 = add nuw nsw i64 %31, 1
%146 = icmp eq i64 %145, %14
br i1 %146, label %121, label %30
147: ; preds = %123, %147
%148 = phi i64 [ 2, %123 ], [ %157, %147 ]
%149 = phi double [ 0.000000e+00, %123 ], [ %156, %147 ]
%150 = getelementptr inbounds double, double* %4, i64 %148
%151 = load double, double* %150
%152 = fadd double %151, 1.000000e-09
%153 = tail call double @log10(double %152)
%154 = fmul double %151, %153
%155 = fdiv double %154, 0x3FD34413509F79FF
%156 = fsub double %149, %155
%157 = add nuw nsw i64 %148, 1
%158 = icmp eq i64 %157, %126
br i1 %158, label %159, label %147
159: ; preds = %147, %2, %6, %121
%160 = phi double [ 0.000000e+00, %121 ], [ 0.000000e+00, %6 ], [ 0.000000e+00, %2 ], [ %156, %147 ]
%161 = tail call i32 @free(double* %4)
ret double %160
}