#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 uint32_t;
typedef scalar_t__ clock_t;

/* Variables and functions */
float CLOCKS_PER_SEC;
scalar_t__ clock();
float log(float);
void entropy_float(float *table, uint32_t *rows, uint32_t *cols,
                   float *entropy_table, float *entropy_rows,
                   float *entropy_cols, float *entropy_rowsGivencols,
                   float *entropy_colsGivenRows, float *dependency_rowsOncols,
                   float *dependency_colsOnRows, float *dependency_symmetrical,
                   float *time_sum_all, float *time_sum_rows,
                   float *time_sum_cols, float *time_entropy_table,
                   float *time_entropy_rows, float *time_entropy_cols) {
  clock_t begin, end;
  float sum_all = 0.0;
  float sum_rows[*rows];
  float sum_cols[*cols];
  float p = 0.0;
  *entropy_table = 0.0;
  *entropy_rows = 0.0;
  *entropy_cols = 0.0;
  *entropy_rowsGivencols = 0.0;
  *entropy_colsGivenRows = 0.0;
  *dependency_rowsOncols = 0.0;
  *dependency_colsOnRows = 0.0;
  *dependency_symmetrical = 0.0;
  begin = clock();
  for (uint32_t row = 0; row < *rows; row++) {
    for (uint32_t col = 0; col < *cols; col++) {
      sum_all += table[row * *cols + col];
    }
  }
  end = clock();
  *time_sum_all = (float)(end - begin) / CLOCKS_PER_SEC;
  begin = clock();
  for (uint32_t row = 0; row < *rows; row++) {
    sum_rows[row] = 0;
    for (uint32_t col = 0; col < *cols; col++) {
      sum_rows[row] += table[row * *cols + col];
    }
  }
  end = clock();
  *time_sum_rows = (float)(end - begin) / CLOCKS_PER_SEC;
  begin = clock();
  for (uint32_t col = 0; col < *cols; col++) {
    sum_cols[col] = 0;
    for (uint32_t row = 0; row < *rows; row++) {
      sum_cols[col] += table[row * *cols + col];
    }
  }
  end = clock();
  *time_sum_cols = (float)(end - begin) / CLOCKS_PER_SEC;
  begin = clock();
  for (uint32_t row = 0; row < *rows; row++) {
    for (uint32_t col = 0; col < *cols; col++) {
      if (table[row * *cols + col]) {
        p = table[row * *cols + col] / sum_all;
        *entropy_table -= p * log(p);
      }
    }
  }
  end = clock();
  *time_entropy_table = (float)(end - begin) / CLOCKS_PER_SEC;
  begin = clock();
  for (uint32_t row = 0; row < *rows; row++) {
    if (sum_rows[row]) {
      p = sum_rows[row] / sum_all;
      *entropy_rows -= p * log(p);
    }
  }
  end = clock();
  *time_entropy_rows = (float)(end - begin) / CLOCKS_PER_SEC;
  begin = clock();
  for (uint32_t col = 0; col < *cols; col++) {
    if (sum_cols[col]) {
      p = sum_cols[col] / sum_all;
      *entropy_cols -= p * log(p);
    }
  }
  end = clock();
  *time_entropy_cols = (float)(end - begin) / CLOCKS_PER_SEC;
  *entropy_rowsGivencols = *entropy_table - *entropy_cols;
  *entropy_colsGivenRows = *entropy_table - *entropy_rows;
  *dependency_rowsOncols =
      (*entropy_rows - *entropy_rowsGivencols) / (*entropy_rows + 1.0e-30);
  *dependency_colsOnRows =
      (*entropy_cols - *entropy_colsGivenRows) / (*entropy_cols + 1.0e-30);
  *dependency_symmetrical = 2.0 *
                            (*entropy_rows + *entropy_cols - *entropy_table) /
                            (*entropy_rows + *entropy_cols + 1.0e-30);
}


x86 assembly (clang, -O0):
<entropy_float>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %rsp,%rcx
mov    %rcx,-0x50(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xa0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x98(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    -0x30(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    0x30(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    $0x0,%al
call   1030 <clock@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    12a4 <entropy_float+0x184>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x18(%rbp),%rcx
cmp    (%rcx),%eax
jge    1291 <entropy_float+0x171>
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
mov    -0x18(%rbp),%rdx
imul   (%rdx),%ecx
add    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1251 <entropy_float+0x131>
jmp    1296 <entropy_float+0x176>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    123b <entropy_float+0x11b>
mov    $0x0,%al
call   1030 <clock@plt>
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
sub    -0x38(%rbp),%rax
cvtsi2ss %rax,%xmm0
mov    0x2d25(%rip),%rax
divss  (%rax),%xmm0
mov    0x38(%rbp),%rax
movss  %xmm0,(%rax)
mov    $0x0,%al
call   1030 <clock@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1368 <entropy_float+0x248>
mov    -0xa0(%rbp),%rax
movslq -0x70(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    -0x18(%rbp),%rcx
cmp    (%rcx),%eax
jge    1355 <entropy_float+0x235>
mov    -0xa0(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x70(%rbp),%edx
mov    -0x18(%rbp),%rsi
imul   (%rsi),%edx
add    -0x74(%rbp),%edx
movslq %edx,%rdx
movss  (%rcx,%rdx,4),%xmm0
movslq -0x70(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    130a <entropy_float+0x1ea>
jmp    135a <entropy_float+0x23a>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    12e1 <entropy_float+0x1c1>
mov    $0x0,%al
call   1030 <clock@plt>
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
sub    -0x38(%rbp),%rax
cvtsi2ss %rax,%xmm0
mov    0x2c61(%rip),%rax
divss  (%rax),%xmm0
mov    0x40(%rbp),%rax
movss  %xmm0,(%rax)
mov    $0x0,%al
call   1030 <clock@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    -0x18(%rbp),%rcx
cmp    (%rcx),%eax
jge    142c <entropy_float+0x30c>
mov    -0x98(%rbp),%rax
movslq -0x78(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1419 <entropy_float+0x2f9>
mov    -0x98(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x7c(%rbp),%edx
mov    -0x18(%rbp),%rsi
imul   (%rsi),%edx
add    -0x78(%rbp),%edx
movslq %edx,%rdx
movss  (%rcx,%rdx,4),%xmm0
movslq -0x78(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    13ce <entropy_float+0x2ae>
jmp    141e <entropy_float+0x2fe>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    13a5 <entropy_float+0x285>
mov    $0x0,%al
call   1030 <clock@plt>
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
sub    -0x38(%rbp),%rax
cvtsi2ss %rax,%xmm0
mov    0x2b9d(%rip),%rax
divss  (%rax),%xmm0
mov    0x48(%rbp),%rax
movss  %xmm0,(%rax)
mov    $0x0,%al
call   1030 <clock@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    155d <entropy_float+0x43d>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    -0x18(%rbp),%rcx
cmp    (%rcx),%eax
jge    154a <entropy_float+0x42a>
mov    -0x8(%rbp),%rax
mov    -0x80(%rbp),%ecx
mov    -0x18(%rbp),%rdx
imul   (%rdx),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    14c7 <entropy_float+0x3a7>
jp     14c7 <entropy_float+0x3a7>
jmp    1531 <entropy_float+0x411>
mov    -0x8(%rbp),%rax
mov    -0x80(%rbp),%ecx
mov    -0x18(%rbp),%rdx
imul   (%rdx),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x64(%rbp),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x64(%rbp),%xmm0
call   1040 <log@plt>
movaps %xmm0,%xmm2
movss  -0xa4(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax)
jmp    1536 <entropy_float+0x416>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1482 <entropy_float+0x362>
jmp    154f <entropy_float+0x42f>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1469 <entropy_float+0x349>
mov    $0x0,%al
call   1030 <clock@plt>
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
sub    -0x38(%rbp),%rax
cvtsi2ss %rax,%xmm0
mov    0x2a6c(%rip),%rax
divss  (%rax),%xmm0
mov    0x50(%rbp),%rax
movss  %xmm0,(%rax)
mov    $0x0,%al
call   1030 <clock@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1653 <entropy_float+0x533>
mov    -0xa0(%rbp),%rax
movslq -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    15d9 <entropy_float+0x4b9>
jp     15d9 <entropy_float+0x4b9>
jmp    163a <entropy_float+0x51a>
mov    -0xa0(%rbp),%rax
movslq -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x64(%rbp),%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0x64(%rbp),%xmm0
call   1040 <log@plt>
movaps %xmm0,%xmm2
movss  -0xa8(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax)
jmp    163f <entropy_float+0x51f>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    159d <entropy_float+0x47d>
mov    $0x0,%al
call   1030 <clock@plt>
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
sub    -0x38(%rbp),%rax
cvtsi2ss %rax,%xmm0
mov    0x2976(%rip),%rax
divss  (%rax),%xmm0
mov    0x58(%rbp),%rax
movss  %xmm0,(%rax)
mov    $0x0,%al
call   1030 <clock@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    -0x18(%rbp),%rcx
cmp    (%rcx),%eax
jge    1749 <entropy_float+0x629>
mov    -0x98(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    16cf <entropy_float+0x5af>
jp     16cf <entropy_float+0x5af>
jmp    1730 <entropy_float+0x610>
mov    -0x98(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x64(%rbp),%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  -0x64(%rbp),%xmm0
call   1040 <log@plt>
movaps %xmm0,%xmm2
movss  -0xac(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax)
jmp    1735 <entropy_float+0x615>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1693 <entropy_float+0x573>
mov    $0x0,%al
call   1030 <clock@plt>
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
sub    -0x38(%rbp),%rax
cvtsi2ss %rax,%xmm0
mov    0x2880(%rip),%rax
divss  (%rax),%xmm0
mov    0x60(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%rbp),%rax
subss  (%rax),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  (%rax),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    0x10(%rbp),%rax
subss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0x834(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x20(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    0x18(%rbp),%rax
subss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0x7f8(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x28(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%rbp),%rax
addss  (%rax),%xmm0
mov    -0x20(%rbp),%rax
subss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x7c8(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x30(%rbp),%rax
addss  (%rax),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0x7a0(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x30(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x50(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<entropy_float>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r8,%r15
mov    %rcx,%r13
mov    %rdx,%r14
mov    %rsi,%rbx
mov    %rdi,%r12
mov    0x30(%rbp),%r8
mov    0x28(%rbp),%r10
mov    0x20(%rbp),%rdi
mov    0x18(%rbp),%rsi
mov    0x10(%rbp),%rcx
mov    (%rbx),%eax
mov    %rsp,%rdx
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rdx
mov    %rdx,-0x58(%rbp)
mov    %rdx,%rsp
mov    (%r14),%eax
mov    %rsp,%rdx
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rdx
mov    %rdx,-0x60(%rbp)
mov    %rdx,%rsp
movl   $0x0,0x0(%r13)
movl   $0x0,(%r15)
mov    %r9,-0x70(%rbp)
movl   $0x0,(%r9)
movl   $0x0,(%rcx)
movl   $0x0,(%rsi)
movl   $0x0,(%rdi)
movl   $0x0,(%r10)
movl   $0x0,(%r8)
xor    %eax,%eax
call   1030 <clock@plt>
mov    %rax,-0x30(%rbp)
mov    %rbx,-0x40(%rbp)
mov    (%rbx),%r9d
test   %r9d,%r9d
mov    %r14,-0x48(%rbp)
jle    1270 <entropy_float+0x150>
mov    (%r14),%r10d
movslq %r10d,%r11
mov    %r10,%r8
add    $0xffffffffffffffff,%r8
mov    %r11d,%edi
and    $0x3,%edi
mov    %r11d,%edx
and    $0xfffffffc,%edx
lea    0xc(%r12),%rbx
shl    $0x2,%r11
xorps  %xmm0,%xmm0
xor    %eax,%eax
mov    %r12,%r14
jmp    121f <entropy_float+0xff>
add    $0x1,%rax
add    %r11,%rbx
add    %r11,%r14
cmp    %r9,%rax
je     1273 <entropy_float+0x153>
test   %r10d,%r10d
jle    1210 <entropy_float+0xf0>
xor    %esi,%esi
cmp    $0x3,%r8
jb     1250 <entropy_float+0x130>
nopl   0x0(%rax)
addss  -0xc(%rbx,%rsi,4),%xmm0
addss  -0x8(%rbx,%rsi,4),%xmm0
addss  -0x4(%rbx,%rsi,4),%xmm0
addss  (%rbx,%rsi,4),%xmm0
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    1230 <entropy_float+0x110>
test   %rdi,%rdi
je     1210 <entropy_float+0xf0>
lea    (%r14,%rsi,4),%rsi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
addss  (%rsi,%rcx,4),%xmm0
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    1260 <entropy_float+0x140>
jmp    1210 <entropy_float+0xf0>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
xor    %eax,%eax
call   1030 <clock@plt>
sub    -0x30(%rbp),%rax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mov    0x2d56(%rip),%rax
divss  (%rax),%xmm0
mov    0x38(%rbp),%rax
movss  %xmm0,(%rax)
xor    %eax,%eax
call   1030 <clock@plt>
mov    %rax,-0x30(%rbp)
mov    -0x40(%rbp),%rax
mov    (%rax),%r9d
test   %r9d,%r9d
jle    1370 <entropy_float+0x250>
mov    -0x48(%rbp),%rax
mov    (%rax),%r10d
movslq %r10d,%r11
mov    %r10,%r8
add    $0xffffffffffffffff,%r8
mov    %r11d,%edi
and    $0x3,%edi
mov    %r11d,%edx
and    $0xfffffffc,%edx
lea    0xc(%r12),%rsi
shl    $0x2,%r11
xor    %eax,%eax
mov    %r12,%r14
jmp    1308 <entropy_float+0x1e8>
cs nopw 0x0(%rax,%rax,1)
mov    -0x58(%rbp),%rcx
movss  %xmm0,(%rcx,%rax,4)
add    $0x1,%rax
add    %r11,%rsi
add    %r11,%r14
cmp    %r9,%rax
je     1370 <entropy_float+0x250>
mov    -0x58(%rbp),%rcx
movl   $0x0,(%rcx,%rax,4)
test   %r10d,%r10d
jle    12f9 <entropy_float+0x1d9>
xorps  %xmm0,%xmm0
xor    %ebx,%ebx
cmp    $0x3,%r8
jb     1350 <entropy_float+0x230>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addss  -0xc(%rsi,%rbx,4),%xmm0
addss  -0x8(%rsi,%rbx,4),%xmm0
addss  -0x4(%rsi,%rbx,4),%xmm0
addss  (%rsi,%rbx,4),%xmm0
add    $0x4,%rbx
cmp    %rbx,%rdx
jne    1330 <entropy_float+0x210>
test   %rdi,%rdi
je     12f0 <entropy_float+0x1d0>
lea    (%r14,%rbx,4),%rbx
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
addss  (%rbx,%rcx,4),%xmm0
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    1360 <entropy_float+0x240>
jmp    12f0 <entropy_float+0x1d0>
mov    %r15,-0x68(%rbp)
xor    %eax,%eax
call   1030 <clock@plt>
sub    -0x30(%rbp),%rax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mov    0x2c5a(%rip),%rax
divss  (%rax),%xmm0
mov    0x40(%rbp),%rax
movss  %xmm0,(%rax)
xor    %eax,%eax
call   1030 <clock@plt>
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
mov    (%rax),%eax
test   %eax,%eax
jle    1492 <entropy_float+0x372>
mov    -0x40(%rbp),%rcx
mov    (%rcx),%r8d
mov    %r8,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x30(%rbp)
mov    %r8d,%r10d
and    $0x3,%r10d
mov    %r8d,%r9d
and    $0xfffffffc,%r9d
mov    %rax,%rdx
shl    $0x4,%rdx
lea    0x0(,%rax,4),%rcx
lea    (%rcx,%rcx,2),%rsi
xor    %r15d,%r15d
mov    %r12,%r14
jmp    140b <entropy_float+0x2eb>
xchg   %ax,%ax
mov    -0x60(%rbp),%rdi
movss  %xmm0,(%rdi,%r15,4)
add    $0x1,%r15
add    $0x4,%r14
cmp    %rax,%r15
je     1492 <entropy_float+0x372>
mov    -0x60(%rbp),%rdi
movl   $0x0,(%rdi,%r15,4)
test   %r8d,%r8d
jle    13fa <entropy_float+0x2da>
cmpq   $0x3,-0x30(%rbp)
jae    1430 <entropy_float+0x310>
xorps  %xmm0,%xmm0
xor    %ebx,%ebx
jmp    1463 <entropy_float+0x343>
nopw   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
mov    %r14,%r11
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
addss  (%r11),%xmm0
addss  (%r11,%rax,4),%xmm0
addss  (%r11,%rax,8),%xmm0
addss  (%r11,%rsi,1),%xmm0
add    $0x4,%rbx
add    %rdx,%r11
cmp    %rbx,%r9
jne    1440 <entropy_float+0x320>
test   %r10,%r10
je     13f0 <entropy_float+0x2d0>
imul   %rax,%rbx
add    %r15,%rbx
lea    (%r12,%rbx,4),%rbx
mov    %r10,%rdi
cs nopw 0x0(%rax,%rax,1)
addss  (%rbx),%xmm0
add    %rcx,%rbx
add    $0xffffffffffffffff,%rdi
jne    1480 <entropy_float+0x360>
jmp    13f0 <entropy_float+0x2d0>
xor    %r15d,%r15d
xor    %eax,%eax
call   1030 <clock@plt>
sub    -0x50(%rbp),%rax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mov    0x2b39(%rip),%rax
divss  (%rax),%xmm0
mov    0x48(%rbp),%rax
movss  %xmm0,(%rax)
xor    %eax,%eax
call   1030 <clock@plt>
mov    %rax,-0x50(%rbp)
mov    -0x40(%rbp),%rax
mov    (%rax),%edx
test   %edx,%edx
mov    -0x48(%rbp),%r14
jle    154e <entropy_float+0x42e>
mov    (%r14),%eax
mov    %eax,%ecx
jmp    14f1 <entropy_float+0x3d1>
nopl   0x0(%rax,%rax,1)
mov    -0x40(%rbp),%rcx
mov    (%rcx),%edx
mov    %eax,%ecx
add    $0x1,%r15d
cmp    %edx,%r15d
jge    154e <entropy_float+0x42e>
test   %ecx,%ecx
jle    14e8 <entropy_float+0x3c8>
xor    %ebx,%ebx
jmp    150a <entropy_float+0x3ea>
nopl   0x0(%rax)
add    $0x1,%rbx
mov    %eax,%ecx
cmp    %eax,%ebx
jge    14e0 <entropy_float+0x3c0>
imul   %r15d,%ecx
movslq %ecx,%rcx
add    %rbx,%rcx
movss  (%r12,%rcx,4),%xmm0
ucomiss 0xae7(%rip),%xmm0
jne    1525 <entropy_float+0x405>
jnp    1500 <entropy_float+0x3e0>
divss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
call   1040 <log@plt>
movss  0x0(%r13),%xmm1
mulss  -0x30(%rbp),%xmm0
subss  %xmm0,%xmm1
movss  %xmm1,0x0(%r13)
mov    (%r14),%eax
jmp    1500 <entropy_float+0x3e0>
xor    %eax,%eax
call   1030 <clock@plt>
sub    -0x50(%rbp),%rax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mov    0x2a80(%rip),%rax
divss  (%rax),%xmm0
mov    0x50(%rbp),%rax
movss  %xmm0,(%rax)
xor    %eax,%eax
call   1030 <clock@plt>
mov    %rax,%r14
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
test   %eax,%eax
mov    -0x70(%rbp),%r12
mov    -0x68(%rbp),%r15
jle    15ea <entropy_float+0x4ca>
xor    %ebx,%ebx
jmp    15ac <entropy_float+0x48c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbx
movslq %eax,%rcx
cmp    %rcx,%rbx
jge    15ea <entropy_float+0x4ca>
mov    -0x58(%rbp),%rcx
movss  (%rcx,%rbx,4),%xmm0
ucomiss 0xa4c(%rip),%xmm0
jne    15c0 <entropy_float+0x4a0>
jnp    15a0 <entropy_float+0x480>
divss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
call   1040 <log@plt>
movss  (%r15),%xmm1
mulss  -0x30(%rbp),%xmm0
subss  %xmm0,%xmm1
movss  %xmm1,(%r15)
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
jmp    15a0 <entropy_float+0x480>
mov    0x60(%rbp),%r15
xor    %eax,%eax
call   1030 <clock@plt>
sub    %r14,%rax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mov    0x29e1(%rip),%rax
divss  (%rax),%xmm0
mov    0x58(%rbp),%rax
movss  %xmm0,(%rax)
xor    %eax,%eax
call   1030 <clock@plt>
mov    %rax,%r14
mov    -0x48(%rbp),%rax
mov    (%rax),%eax
test   %eax,%eax
jle    167c <entropy_float+0x55c>
xor    %ebx,%ebx
jmp    163c <entropy_float+0x51c>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
movslq %eax,%rcx
cmp    %rcx,%rbx
jge    167c <entropy_float+0x55c>
mov    -0x60(%rbp),%rcx
movss  (%rcx,%rbx,4),%xmm0
ucomiss 0x9bc(%rip),%xmm0
jne    1650 <entropy_float+0x530>
jnp    1630 <entropy_float+0x510>
divss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
call   1040 <log@plt>
movss  (%r12),%xmm1
mulss  -0x30(%rbp),%xmm0
subss  %xmm0,%xmm1
movss  %xmm1,(%r12)
mov    -0x48(%rbp),%rax
mov    (%rax),%eax
jmp    1630 <entropy_float+0x510>
xor    %eax,%eax
call   1030 <clock@plt>
sub    %r14,%rax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mov    0x2953(%rip),%rax
divss  (%rax),%xmm0
movss  %xmm0,(%r15)
movss  0x0(%r13),%xmm0
subss  (%r12),%xmm0
mov    0x10(%rbp),%rdx
movss  %xmm0,(%rdx)
movss  0x0(%r13),%xmm0
mov    -0x68(%rbp),%rax
subss  (%rax),%xmm0
mov    0x18(%rbp),%rcx
movss  %xmm0,(%rcx)
movss  (%rax),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
subss  (%rdx),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x91d(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x20(%rbp),%rdx
movss  %xmm0,(%rdx)
movss  (%r12),%xmm0
movaps %xmm0,%xmm1
subss  (%rcx),%xmm1
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
addsd  %xmm2,%xmm0
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
mov    0x28(%rbp),%rcx
movss  %xmm0,(%rcx)
movss  (%rax),%xmm0
addss  (%r12),%xmm0
movaps %xmm0,%xmm1
subss  0x0(%r13),%xmm1
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm2,%xmm0
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
mov    0x30(%rbp),%rax
movss  %xmm0,(%rax)
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@CLOCKS_PER_SEC = global float 0.000000e+00
define void @entropy_float(float* %0, i32* %1, i32* %2, float* %3, float* %4, float* %5, float* %6, float* %7, float* %8, float* %9, float* %10, float* %11, float* %12, float* %13, float* %14, float* %15, float* %16) {
%18 = alloca float*
%19 = alloca i32*
%20 = alloca i32*
%21 = alloca float*
%22 = alloca float*
%23 = alloca float*
%24 = alloca float*
%25 = alloca float*
%26 = alloca float*
%27 = alloca float*
%28 = alloca float*
%29 = alloca float*
%30 = alloca float*
%31 = alloca float*
%32 = alloca float*
%33 = alloca float*
%34 = alloca float*
%35 = alloca i64
%36 = alloca i64
%37 = alloca float
%38 = alloca i8*
%39 = alloca i64
%40 = alloca i64
%41 = alloca float
%42 = alloca i32
%43 = alloca i32
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
%47 = alloca i32
%48 = alloca i32
%49 = alloca i32
%50 = alloca i32
%51 = alloca i32
store float* %0, float** %18
store i32* %1, i32** %19
store i32* %2, i32** %20
store float* %3, float** %21
store float* %4, float** %22
store float* %5, float** %23
store float* %6, float** %24
store float* %7, float** %25
store float* %8, float** %26
store float* %9, float** %27
store float* %10, float** %28
store float* %11, float** %29
store float* %12, float** %30
store float* %13, float** %31
store float* %14, float** %32
store float* %15, float** %33
store float* %16, float** %34
store float 0.000000e+00, float* %37
%52 = load i32*, i32** %19
%53 = load i32, i32* %52
%54 = zext i32 %53 to i64
%55 = call i8* @llvm.stacksave()
store i8* %55, i8** %38
%56 = alloca float, i64 %54
store i64 %54, i64* %39
%57 = load i32*, i32** %20
%58 = load i32, i32* %57
%59 = zext i32 %58 to i64
%60 = alloca float, i64 %59
store i64 %59, i64* %40
store float 0.000000e+00, float* %41
%61 = load float*, float** %21
store float 0.000000e+00, float* %61
%62 = load float*, float** %22
store float 0.000000e+00, float* %62
%63 = load float*, float** %23
store float 0.000000e+00, float* %63
%64 = load float*, float** %24
store float 0.000000e+00, float* %64
%65 = load float*, float** %25
store float 0.000000e+00, float* %65
%66 = load float*, float** %26
store float 0.000000e+00, float* %66
%67 = load float*, float** %27
store float 0.000000e+00, float* %67
%68 = load float*, float** %28
store float 0.000000e+00, float* %68
%69 = call i64 (...) @clock()
store i64 %69, i64* %35
store i32 0, i32* %42
br label %70
70: ; preds = %98, %17
%71 = load i32, i32* %42
%72 = load i32*, i32** %19
%73 = load i32, i32* %72
%74 = icmp slt i32 %71, %73
br i1 %74, label %75, label %101
75: ; preds = %70
store i32 0, i32* %43
br label %76
76: ; preds = %94, %75
%77 = load i32, i32* %43
%78 = load i32*, i32** %20
%79 = load i32, i32* %78
%80 = icmp slt i32 %77, %79
br i1 %80, label %81, label %97
81: ; preds = %76
%82 = load float*, float** %18
%83 = load i32, i32* %42
%84 = load i32*, i32** %20
%85 = load i32, i32* %84
%86 = mul nsw i32 %83, %85
%87 = load i32, i32* %43
%88 = add nsw i32 %86, %87
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds float, float* %82, i64 %89
%91 = load float, float* %90
%92 = load float, float* %37
%93 = fadd float %92, %91
store float %93, float* %37
br label %94
94: ; preds = %81
%95 = load i32, i32* %43
%96 = add nsw i32 %95, 1
store i32 %96, i32* %43
br label %76
97: ; preds = %76
br label %98
98: ; preds = %97
%99 = load i32, i32* %42
%100 = add nsw i32 %99, 1
store i32 %100, i32* %42
br label %70
101: ; preds = %70
%102 = call i64 (...) @clock()
store i64 %102, i64* %36
%103 = load i64, i64* %36
%104 = load i64, i64* %35
%105 = sub nsw i64 %103, %104
%106 = sitofp i64 %105 to float
%107 = load float, float* @CLOCKS_PER_SEC
%108 = fdiv float %106, %107
%109 = load float*, float** %29
store float %108, float* %109
%110 = call i64 (...) @clock()
store i64 %110, i64* %35
store i32 0, i32* %44
br label %111
111: ; preds = %145, %101
%112 = load i32, i32* %44
%113 = load i32*, i32** %19
%114 = load i32, i32* %113
%115 = icmp slt i32 %112, %114
br i1 %115, label %116, label %148
116: ; preds = %111
%117 = load i32, i32* %44
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds float, float* %56, i64 %118
store float 0.000000e+00, float* %119
store i32 0, i32* %45
br label %120
120: ; preds = %141, %116
%121 = load i32, i32* %45
%122 = load i32*, i32** %20
%123 = load i32, i32* %122
%124 = icmp slt i32 %121, %123
br i1 %124, label %125, label %144
125: ; preds = %120
%126 = load float*, float** %18
%127 = load i32, i32* %44
%128 = load i32*, i32** %20
%129 = load i32, i32* %128
%130 = mul nsw i32 %127, %129
%131 = load i32, i32* %45
%132 = add nsw i32 %130, %131
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds float, float* %126, i64 %133
%135 = load float, float* %134
%136 = load i32, i32* %44
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds float, float* %56, i64 %137
%139 = load float, float* %138
%140 = fadd float %139, %135
store float %140, float* %138
br label %141
141: ; preds = %125
%142 = load i32, i32* %45
%143 = add nsw i32 %142, 1
store i32 %143, i32* %45
br label %120
144: ; preds = %120
br label %145
145: ; preds = %144
%146 = load i32, i32* %44
%147 = add nsw i32 %146, 1
store i32 %147, i32* %44
br label %111
148: ; preds = %111
%149 = call i64 (...) @clock()
store i64 %149, i64* %36
%150 = load i64, i64* %36
%151 = load i64, i64* %35
%152 = sub nsw i64 %150, %151
%153 = sitofp i64 %152 to float
%154 = load float, float* @CLOCKS_PER_SEC
%155 = fdiv float %153, %154
%156 = load float*, float** %30
store float %155, float* %156
%157 = call i64 (...) @clock()
store i64 %157, i64* %35
store i32 0, i32* %46
br label %158
158: ; preds = %192, %148
%159 = load i32, i32* %46
%160 = load i32*, i32** %20
%161 = load i32, i32* %160
%162 = icmp slt i32 %159, %161
br i1 %162, label %163, label %195
163: ; preds = %158
%164 = load i32, i32* %46
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds float, float* %60, i64 %165
store float 0.000000e+00, float* %166
store i32 0, i32* %47
br label %167
167: ; preds = %188, %163
%168 = load i32, i32* %47
%169 = load i32*, i32** %19
%170 = load i32, i32* %169
%171 = icmp slt i32 %168, %170
br i1 %171, label %172, label %191
172: ; preds = %167
%173 = load float*, float** %18
%174 = load i32, i32* %47
%175 = load i32*, i32** %20
%176 = load i32, i32* %175
%177 = mul nsw i32 %174, %176
%178 = load i32, i32* %46
%179 = add nsw i32 %177, %178
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds float, float* %173, i64 %180
%182 = load float, float* %181
%183 = load i32, i32* %46
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds float, float* %60, i64 %184
%186 = load float, float* %185
%187 = fadd float %186, %182
store float %187, float* %185
br label %188
188: ; preds = %172
%189 = load i32, i32* %47
%190 = add nsw i32 %189, 1
store i32 %190, i32* %47
br label %167
191: ; preds = %167
br label %192
192: ; preds = %191
%193 = load i32, i32* %46
%194 = add nsw i32 %193, 1
store i32 %194, i32* %46
br label %158
195: ; preds = %158
%196 = call i64 (...) @clock()
store i64 %196, i64* %36
%197 = load i64, i64* %36
%198 = load i64, i64* %35
%199 = sub nsw i64 %197, %198
%200 = sitofp i64 %199 to float
%201 = load float, float* @CLOCKS_PER_SEC
%202 = fdiv float %200, %201
%203 = load float*, float** %31
store float %202, float* %203
%204 = call i64 (...) @clock()
store i64 %204, i64* %35
store i32 0, i32* %48
br label %205
205: ; preds = %253, %195
%206 = load i32, i32* %48
%207 = load i32*, i32** %19
%208 = load i32, i32* %207
%209 = icmp slt i32 %206, %208
br i1 %209, label %210, label %256
210: ; preds = %205
store i32 0, i32* %49
br label %211
211: ; preds = %249, %210
%212 = load i32, i32* %49
%213 = load i32*, i32** %20
%214 = load i32, i32* %213
%215 = icmp slt i32 %212, %214
br i1 %215, label %216, label %252
216: ; preds = %211
%217 = load float*, float** %18
%218 = load i32, i32* %48
%219 = load i32*, i32** %20
%220 = load i32, i32* %219
%221 = mul nsw i32 %218, %220
%222 = load i32, i32* %49
%223 = add nsw i32 %221, %222
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds float, float* %217, i64 %224
%226 = load float, float* %225
%227 = fcmp une float %226, 0.000000e+00
br i1 %227, label %228, label %248
228: ; preds = %216
%229 = load float*, float** %18
%230 = load i32, i32* %48
%231 = load i32*, i32** %20
%232 = load i32, i32* %231
%233 = mul nsw i32 %230, %232
%234 = load i32, i32* %49
%235 = add nsw i32 %233, %234
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds float, float* %229, i64 %236
%238 = load float, float* %237
%239 = load float, float* %37
%240 = fdiv float %238, %239
store float %240, float* %41
%241 = load float, float* %41
%242 = load float, float* %41
%243 = call float @log(float %242)
%244 = load float*, float** %21
%245 = load float, float* %244
%246 = fneg float %241
%247 = call float @llvm.fmuladd.f32(float %246, float %243, float %245)
store float %247, float* %244
br label %248
248: ; preds = %228, %216
br label %249
249: ; preds = %248
%250 = load i32, i32* %49
%251 = add nsw i32 %250, 1
store i32 %251, i32* %49
br label %211
252: ; preds = %211
br label %253
253: ; preds = %252
%254 = load i32, i32* %48
%255 = add nsw i32 %254, 1
store i32 %255, i32* %48
br label %205
256: ; preds = %205
%257 = call i64 (...) @clock()
store i64 %257, i64* %36
%258 = load i64, i64* %36
%259 = load i64, i64* %35
%260 = sub nsw i64 %258, %259
%261 = sitofp i64 %260 to float
%262 = load float, float* @CLOCKS_PER_SEC
%263 = fdiv float %261, %262
%264 = load float*, float** %32
store float %263, float* %264
%265 = call i64 (...) @clock()
store i64 %265, i64* %35
store i32 0, i32* %50
br label %266
266: ; preds = %292, %256
%267 = load i32, i32* %50
%268 = load i32*, i32** %19
%269 = load i32, i32* %268
%270 = icmp slt i32 %267, %269
br i1 %270, label %271, label %295
271: ; preds = %266
%272 = load i32, i32* %50
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds float, float* %56, i64 %273
%275 = load float, float* %274
%276 = fcmp une float %275, 0.000000e+00
br i1 %276, label %277, label %291
277: ; preds = %271
%278 = load i32, i32* %50
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds float, float* %56, i64 %279
%281 = load float, float* %280
%282 = load float, float* %37
%283 = fdiv float %281, %282
store float %283, float* %41
%284 = load float, float* %41
%285 = load float, float* %41
%286 = call float @log(float %285)
%287 = load float*, float** %22
%288 = load float, float* %287
%289 = fneg float %284
%290 = call float @llvm.fmuladd.f32(float %289, float %286, float %288)
store float %290, float* %287
br label %291
291: ; preds = %277, %271
br label %292
292: ; preds = %291
%293 = load i32, i32* %50
%294 = add nsw i32 %293, 1
store i32 %294, i32* %50
br label %266
295: ; preds = %266
%296 = call i64 (...) @clock()
store i64 %296, i64* %36
%297 = load i64, i64* %36
%298 = load i64, i64* %35
%299 = sub nsw i64 %297, %298
%300 = sitofp i64 %299 to float
%301 = load float, float* @CLOCKS_PER_SEC
%302 = fdiv float %300, %301
%303 = load float*, float** %33
store float %302, float* %303
%304 = call i64 (...) @clock()
store i64 %304, i64* %35
store i32 0, i32* %51
br label %305
305: ; preds = %331, %295
%306 = load i32, i32* %51
%307 = load i32*, i32** %20
%308 = load i32, i32* %307
%309 = icmp slt i32 %306, %308
br i1 %309, label %310, label %334
310: ; preds = %305
%311 = load i32, i32* %51
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds float, float* %60, i64 %312
%314 = load float, float* %313
%315 = fcmp une float %314, 0.000000e+00
br i1 %315, label %316, label %330
316: ; preds = %310
%317 = load i32, i32* %51
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds float, float* %60, i64 %318
%320 = load float, float* %319
%321 = load float, float* %37
%322 = fdiv float %320, %321
store float %322, float* %41
%323 = load float, float* %41
%324 = load float, float* %41
%325 = call float @log(float %324)
%326 = load float*, float** %23
%327 = load float, float* %326
%328 = fneg float %323
%329 = call float @llvm.fmuladd.f32(float %328, float %325, float %327)
store float %329, float* %326
br label %330
330: ; preds = %316, %310
br label %331
331: ; preds = %330
%332 = load i32, i32* %51
%333 = add nsw i32 %332, 1
store i32 %333, i32* %51
br label %305
334: ; preds = %305
%335 = call i64 (...) @clock()
store i64 %335, i64* %36
%336 = load i64, i64* %36
%337 = load i64, i64* %35
%338 = sub nsw i64 %336, %337
%339 = sitofp i64 %338 to float
%340 = load float, float* @CLOCKS_PER_SEC
%341 = fdiv float %339, %340
%342 = load float*, float** %34
store float %341, float* %342
%343 = load float*, float** %21
%344 = load float, float* %343
%345 = load float*, float** %23
%346 = load float, float* %345
%347 = fsub float %344, %346
%348 = load float*, float** %24
store float %347, float* %348
%349 = load float*, float** %21
%350 = load float, float* %349
%351 = load float*, float** %22
%352 = load float, float* %351
%353 = fsub float %350, %352
%354 = load float*, float** %25
store float %353, float* %354
%355 = load float*, float** %22
%356 = load float, float* %355
%357 = load float*, float** %24
%358 = load float, float* %357
%359 = fsub float %356, %358
%360 = fpext float %359 to double
%361 = load float*, float** %22
%362 = load float, float* %361
%363 = fpext float %362 to double
%364 = fadd double %363, 1.000000e-30
%365 = fdiv double %360, %364
%366 = fptrunc double %365 to float
%367 = load float*, float** %26
store float %366, float* %367
%368 = load float*, float** %23
%369 = load float, float* %368
%370 = load float*, float** %25
%371 = load float, float* %370
%372 = fsub float %369, %371
%373 = fpext float %372 to double
%374 = load float*, float** %23
%375 = load float, float* %374
%376 = fpext float %375 to double
%377 = fadd double %376, 1.000000e-30
%378 = fdiv double %373, %377
%379 = fptrunc double %378 to float
%380 = load float*, float** %27
store float %379, float* %380
%381 = load float*, float** %22
%382 = load float, float* %381
%383 = load float*, float** %23
%384 = load float, float* %383
%385 = fadd float %382, %384
%386 = load float*, float** %21
%387 = load float, float* %386
%388 = fsub float %385, %387
%389 = fpext float %388 to double
%390 = fmul double 2.000000e+00, %389
%391 = load float*, float** %22
%392 = load float, float* %391
%393 = load float*, float** %23
%394 = load float, float* %393
%395 = fadd float %392, %394
%396 = fpext float %395 to double
%397 = fadd double %396, 1.000000e-30
%398 = fdiv double %390, %397
%399 = fptrunc double %398 to float
%400 = load float*, float** %28
store float %399, float* %400
%401 = load i8*, i8** %38
ret void
}

LLVM IR (-O2):
@CLOCKS_PER_SEC = global float 0.000000e+00
define void @entropy_float(float* nocapture %0, i32* nocapture %1, i32* nocapture %2, float* nocapture %3, float* nocapture %4, float* nocapture %5, float* nocapture %6, float* nocapture %7, float* nocapture writeonly %8, float* nocapture writeonly %9, float* nocapture writeonly %10, float* nocapture writeonly %11, float* nocapture writeonly %12, float* nocapture writeonly %13, float* nocapture writeonly %14, float* nocapture writeonly %15, float* nocapture writeonly %16) {
%18 = load i32, i32* %1
%19 = zext i32 %18 to i64
%20 = alloca float, i64 %19
%21 = load i32, i32* %2
%22 = zext i32 %21 to i64
%23 = alloca float, i64 %22
store float 0.000000e+00, float* %3
store float 0.000000e+00, float* %4
store float 0.000000e+00, float* %5
store float 0.000000e+00, float* %6
store float 0.000000e+00, float* %7
store float 0.000000e+00, float* %8
store float 0.000000e+00, float* %9
store float 0.000000e+00, float* %10
%24 = tail call i64 (...) @clock()
%25 = load i32, i32* %1
%26 = icmp sgt i32 %25, 0
br i1 %26, label %27, label %43
27: ; preds = %17
%28 = load i32, i32* %2
%29 = icmp sgt i32 %28, 0
%30 = sext i32 %28 to i64
%31 = zext i32 %25 to i64
%32 = zext i32 %28 to i64
%33 = add nsw i64 %32, -1
%34 = and i64 %32, 3
%35 = icmp ult i64 %33, 3
%36 = and i64 %32, 4294967292
%37 = icmp eq i64 %34, 0
br label %38
38: ; preds = %27, %79
%39 = phi i64 [ 0, %27 ], [ %81, %79 ]
%40 = phi float [ 0.000000e+00, %27 ], [ %80, %79 ]
br i1 %29, label %41, label %79
41: ; preds = %38
%42 = mul nsw i64 %39, %30
br i1 %35, label %64, label %83
43: ; preds = %79, %17
%44 = phi float [ 0.000000e+00, %17 ], [ %80, %79 ]
%45 = tail call i64 (...) @clock()
%46 = sub nsw i64 %45, %24
%47 = sitofp i64 %46 to float
%48 = load float, float* @CLOCKS_PER_SEC
%49 = fdiv float %47, %48
store float %49, float* %11
%50 = tail call i64 (...) @clock()
%51 = load i32, i32* %1
%52 = icmp sgt i32 %51, 0
br i1 %52, label %53, label %109
53: ; preds = %43
%54 = load i32, i32* %2
%55 = icmp sgt i32 %54, 0
%56 = sext i32 %54 to i64
%57 = zext i32 %51 to i64
%58 = zext i32 %54 to i64
%59 = add nsw i64 %58, -1
%60 = and i64 %58, 3
%61 = icmp ult i64 %59, 3
%62 = and i64 %58, 4294967292
%63 = icmp eq i64 %60, 0
br label %129
64: ; preds = %83, %41
%65 = phi float [ undef, %41 ], [ %105, %83 ]
%66 = phi i64 [ 0, %41 ], [ %106, %83 ]
%67 = phi float [ %40, %41 ], [ %105, %83 ]
br i1 %37, label %79, label %68
68: ; preds = %64, %68
%69 = phi i64 [ %76, %68 ], [ %66, %64 ]
%70 = phi float [ %75, %68 ], [ %67, %64 ]
%71 = phi i64 [ %77, %68 ], [ 0, %64 ]
%72 = add nsw i64 %42, %69
%73 = getelementptr inbounds float, float* %0, i64 %72
%74 = load float, float* %73
%75 = fadd float %70, %74
%76 = add nuw nsw i64 %69, 1
%77 = add i64 %71, 1
%78 = icmp eq i64 %77, %34
br i1 %78, label %79, label %68
79: ; preds = %64, %68, %38
%80 = phi float [ %40, %38 ], [ %65, %64 ], [ %75, %68 ]
%81 = add nuw nsw i64 %39, 1
%82 = icmp eq i64 %81, %31
br i1 %82, label %43, label %38
83: ; preds = %41, %83
%84 = phi i64 [ %106, %83 ], [ 0, %41 ]
%85 = phi float [ %105, %83 ], [ %40, %41 ]
%86 = phi i64 [ %107, %83 ], [ 0, %41 ]
%87 = add nsw i64 %42, %84
%88 = getelementptr inbounds float, float* %0, i64 %87
%89 = load float, float* %88
%90 = fadd float %85, %89
%91 = or i64 %84, 1
%92 = add nsw i64 %42, %91
%93 = getelementptr inbounds float, float* %0, i64 %92
%94 = load float, float* %93
%95 = fadd float %90, %94
%96 = or i64 %84, 2
%97 = add nsw i64 %42, %96
%98 = getelementptr inbounds float, float* %0, i64 %97
%99 = load float, float* %98
%100 = fadd float %95, %99
%101 = or i64 %84, 3
%102 = add nsw i64 %42, %101
%103 = getelementptr inbounds float, float* %0, i64 %102
%104 = load float, float* %103
%105 = fadd float %100, %104
%106 = add nuw nsw i64 %84, 4
%107 = add i64 %86, 4
%108 = icmp eq i64 %107, %36
br i1 %108, label %64, label %83
109: ; preds = %151, %43
%110 = tail call i64 (...) @clock()
%111 = sub nsw i64 %110, %50
%112 = sitofp i64 %111 to float
%113 = load float, float* @CLOCKS_PER_SEC
%114 = fdiv float %112, %113
store float %114, float* %12
%115 = tail call i64 (...) @clock()
%116 = load i32, i32* %2
%117 = icmp sgt i32 %116, 0
br i1 %117, label %118, label %180
118: ; preds = %109
%119 = load i32, i32* %1
%120 = icmp sgt i32 %119, 0
%121 = zext i32 %116 to i64
%122 = zext i32 %116 to i64
%123 = zext i32 %119 to i64
%124 = add nsw i64 %123, -1
%125 = and i64 %123, 3
%126 = icmp ult i64 %124, 3
%127 = and i64 %123, 4294967292
%128 = icmp eq i64 %125, 0
br label %191
129: ; preds = %53, %151
%130 = phi i64 [ 0, %53 ], [ %152, %151 ]
%131 = getelementptr inbounds float, float* %20, i64 %130
store float 0.000000e+00, float* %131
br i1 %55, label %132, label %151
132: ; preds = %129
%133 = mul nsw i64 %130, %56
br i1 %61, label %134, label %154
134: ; preds = %154, %132
%135 = phi float [ undef, %132 ], [ %176, %154 ]
%136 = phi i64 [ 0, %132 ], [ %177, %154 ]
%137 = phi float [ 0.000000e+00, %132 ], [ %176, %154 ]
br i1 %63, label %149, label %138
138: ; preds = %134, %138
%139 = phi i64 [ %146, %138 ], [ %136, %134 ]
%140 = phi float [ %145, %138 ], [ %137, %134 ]
%141 = phi i64 [ %147, %138 ], [ 0, %134 ]
%142 = add nsw i64 %133, %139
%143 = getelementptr inbounds float, float* %0, i64 %142
%144 = load float, float* %143
%145 = fadd float %144, %140
%146 = add nuw nsw i64 %139, 1
%147 = add i64 %141, 1
%148 = icmp eq i64 %147, %60
br i1 %148, label %149, label %138
149: ; preds = %138, %134
%150 = phi float [ %135, %134 ], [ %145, %138 ]
store float %150, float* %131
br label %151
151: ; preds = %149, %129
%152 = add nuw nsw i64 %130, 1
%153 = icmp eq i64 %152, %57
br i1 %153, label %109, label %129
154: ; preds = %132, %154
%155 = phi i64 [ %177, %154 ], [ 0, %132 ]
%156 = phi float [ %176, %154 ], [ 0.000000e+00, %132 ]
%157 = phi i64 [ %178, %154 ], [ 0, %132 ]
%158 = add nsw i64 %133, %155
%159 = getelementptr inbounds float, float* %0, i64 %158
%160 = load float, float* %159
%161 = fadd float %160, %156
%162 = or i64 %155, 1
%163 = add nsw i64 %133, %162
%164 = getelementptr inbounds float, float* %0, i64 %163
%165 = load float, float* %164
%166 = fadd float %165, %161
%167 = or i64 %155, 2
%168 = add nsw i64 %133, %167
%169 = getelementptr inbounds float, float* %0, i64 %168
%170 = load float, float* %169
%171 = fadd float %170, %166
%172 = or i64 %155, 3
%173 = add nsw i64 %133, %172
%174 = getelementptr inbounds float, float* %0, i64 %173
%175 = load float, float* %174
%176 = fadd float %175, %171
%177 = add nuw nsw i64 %155, 4
%178 = add i64 %157, 4
%179 = icmp eq i64 %178, %62
br i1 %179, label %134, label %154
180: ; preds = %213, %109
%181 = tail call i64 (...) @clock()
%182 = sub nsw i64 %181, %115
%183 = sitofp i64 %182 to float
%184 = load float, float* @CLOCKS_PER_SEC
%185 = fdiv float %183, %184
store float %185, float* %13
%186 = tail call i64 (...) @clock()
%187 = load i32, i32* %1
%188 = icmp sgt i32 %187, 0
br i1 %188, label %189, label %252
189: ; preds = %180
%190 = load i32, i32* %2
br label %246
191: ; preds = %118, %213
%192 = phi i64 [ 0, %118 ], [ %214, %213 ]
%193 = getelementptr inbounds float, float* %23, i64 %192
store float 0.000000e+00, float* %193
br i1 %120, label %194, label %213
194: ; preds = %191
br i1 %126, label %195, label %216
195: ; preds = %216, %194
%196 = phi float [ undef, %194 ], [ %242, %216 ]
%197 = phi i64 [ 0, %194 ], [ %243, %216 ]
%198 = phi float [ 0.000000e+00, %194 ], [ %242, %216 ]
br i1 %128, label %211, label %199
199: ; preds = %195, %199
%200 = phi i64 [ %208, %199 ], [ %197, %195 ]
%201 = phi float [ %207, %199 ], [ %198, %195 ]
%202 = phi i64 [ %209, %199 ], [ 0, %195 ]
%203 = mul nsw i64 %200, %121
%204 = add nuw nsw i64 %203, %192
%205 = getelementptr inbounds float, float* %0, i64 %204
%206 = load float, float* %205
%207 = fadd float %206, %201
%208 = add nuw nsw i64 %200, 1
%209 = add i64 %202, 1
%210 = icmp eq i64 %209, %125
br i1 %210, label %211, label %199
211: ; preds = %199, %195
%212 = phi float [ %196, %195 ], [ %207, %199 ]
store float %212, float* %193
br label %213
213: ; preds = %211, %191
%214 = add nuw nsw i64 %192, 1
%215 = icmp eq i64 %214, %122
br i1 %215, label %180, label %191
216: ; preds = %194, %216
%217 = phi i64 [ %243, %216 ], [ 0, %194 ]
%218 = phi float [ %242, %216 ], [ 0.000000e+00, %194 ]
%219 = phi i64 [ %244, %216 ], [ 0, %194 ]
%220 = mul nsw i64 %217, %121
%221 = add nuw nsw i64 %220, %192
%222 = getelementptr inbounds float, float* %0, i64 %221
%223 = load float, float* %222
%224 = fadd float %223, %218
%225 = or i64 %217, 1
%226 = mul nsw i64 %225, %121
%227 = add nuw nsw i64 %226, %192
%228 = getelementptr inbounds float, float* %0, i64 %227
%229 = load float, float* %228
%230 = fadd float %229, %224
%231 = or i64 %217, 2
%232 = mul nsw i64 %231, %121
%233 = add nuw nsw i64 %232, %192
%234 = getelementptr inbounds float, float* %0, i64 %233
%235 = load float, float* %234
%236 = fadd float %235, %230
%237 = or i64 %217, 3
%238 = mul nsw i64 %237, %121
%239 = add nuw nsw i64 %238, %192
%240 = getelementptr inbounds float, float* %0, i64 %239
%241 = load float, float* %240
%242 = fadd float %241, %236
%243 = add nuw nsw i64 %217, 4
%244 = add i64 %219, 4
%245 = icmp eq i64 %244, %127
br i1 %245, label %195, label %216
246: ; preds = %189, %263
%247 = phi i32 [ %264, %263 ], [ %187, %189 ]
%248 = phi i32 [ %265, %263 ], [ %190, %189 ]
%249 = phi i32 [ %266, %263 ], [ %190, %189 ]
%250 = phi i32 [ %267, %263 ], [ 0, %189 ]
%251 = icmp sgt i32 %249, 0
br i1 %251, label %269, label %263
252: ; preds = %263, %180
%253 = tail call i64 (...) @clock()
%254 = sub nsw i64 %253, %186
%255 = sitofp i64 %254 to float
%256 = load float, float* @CLOCKS_PER_SEC
%257 = fdiv float %255, %256
store float %257, float* %14
%258 = tail call i64 (...) @clock()
%259 = load i32, i32* %1
%260 = icmp sgt i32 %259, 0
br i1 %260, label %299, label %290
261: ; preds = %286
%262 = load i32, i32* %1
br label %263
263: ; preds = %261, %246
%264 = phi i32 [ %262, %261 ], [ %247, %246 ]
%265 = phi i32 [ %287, %261 ], [ %248, %246 ]
%266 = phi i32 [ %287, %261 ], [ %249, %246 ]
%267 = add nuw nsw i32 %250, 1
%268 = icmp slt i32 %267, %264
br i1 %268, label %246, label %252
269: ; preds = %246, %286
%270 = phi i32 [ %287, %286 ], [ %248, %246 ]
%271 = phi i32 [ %287, %286 ], [ %249, %246 ]
%272 = phi i32 [ %288, %286 ], [ 0, %246 ]
%273 = mul nsw i32 %271, %250
%274 = add nsw i32 %273, %272
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds float, float* %0, i64 %275
%277 = load float, float* %276
%278 = fcmp une float %277, 0.000000e+00
br i1 %278, label %279, label %286
279: ; preds = %269
%280 = fdiv float %277, %44
%281 = tail call float @log(float %280)
%282 = load float, float* %3
%283 = fneg float %280
%284 = tail call float @llvm.fmuladd.f32(float %283, float %281, float %282)
store float %284, float* %3
%285 = load i32, i32* %2
br label %286
286: ; preds = %269, %279
%287 = phi i32 [ %270, %269 ], [ %285, %279 ]
%288 = add nuw nsw i32 %272, 1
%289 = icmp slt i32 %288, %287
br i1 %289, label %269, label %261
290: ; preds = %312, %252
%291 = tail call i64 (...) @clock()
%292 = sub nsw i64 %291, %258
%293 = sitofp i64 %292 to float
%294 = load float, float* @CLOCKS_PER_SEC
%295 = fdiv float %293, %294
store float %295, float* %15
%296 = tail call i64 (...) @clock()
%297 = load i32, i32* %2
%298 = icmp sgt i32 %297, 0
br i1 %298, label %356, label %317
299: ; preds = %252, %312
%300 = phi i32 [ %313, %312 ], [ %259, %252 ]
%301 = phi i64 [ %314, %312 ], [ 0, %252 ]
%302 = getelementptr inbounds float, float* %20, i64 %301
%303 = load float, float* %302
%304 = fcmp une float %303, 0.000000e+00
br i1 %304, label %305, label %312
305: ; preds = %299
%306 = fdiv float %303, %44
%307 = tail call float @log(float %306)
%308 = load float, float* %4
%309 = fneg float %306
%310 = tail call float @llvm.fmuladd.f32(float %309, float %307, float %308)
store float %310, float* %4
%311 = load i32, i32* %1
br label %312
312: ; preds = %299, %305
%313 = phi i32 [ %300, %299 ], [ %311, %305 ]
%314 = add nuw nsw i64 %301, 1
%315 = sext i32 %313 to i64
%316 = icmp slt i64 %314, %315
br i1 %316, label %299, label %290
317: ; preds = %369, %290
%318 = tail call i64 (...) @clock()
%319 = sub nsw i64 %318, %296
%320 = sitofp i64 %319 to float
%321 = load float, float* @CLOCKS_PER_SEC
%322 = fdiv float %320, %321
store float %322, float* %16
%323 = load float, float* %3
%324 = load float, float* %5
%325 = fsub float %323, %324
store float %325, float* %6
%326 = load float, float* %3
%327 = load float, float* %4
%328 = fsub float %326, %327
store float %328, float* %7
%329 = load float, float* %4
%330 = load float, float* %6
%331 = fsub float %329, %330
%332 = fpext float %331 to double
%333 = fpext float %329 to double
%334 = fadd double %333, 1.000000e-30
%335 = fdiv double %332, %334
%336 = fptrunc double %335 to float
store float %336, float* %8
%337 = load float, float* %5
%338 = load float, float* %7
%339 = fsub float %337, %338
%340 = fpext float %339 to double
%341 = fpext float %337 to double
%342 = fadd double %341, 1.000000e-30
%343 = fdiv double %340, %342
%344 = fptrunc double %343 to float
store float %344, float* %9
%345 = load float, float* %4
%346 = load float, float* %5
%347 = fadd float %345, %346
%348 = load float, float* %3
%349 = fsub float %347, %348
%350 = fpext float %349 to double
%351 = fmul double %350, 2.000000e+00
%352 = fpext float %347 to double
%353 = fadd double %352, 1.000000e-30
%354 = fdiv double %351, %353
%355 = fptrunc double %354 to float
store float %355, float* %10
ret void
356: ; preds = %290, %369
%357 = phi i32 [ %370, %369 ], [ %297, %290 ]
%358 = phi i64 [ %371, %369 ], [ 0, %290 ]
%359 = getelementptr inbounds float, float* %23, i64 %358
%360 = load float, float* %359
%361 = fcmp une float %360, 0.000000e+00
br i1 %361, label %362, label %369
362: ; preds = %356
%363 = fdiv float %360, %44
%364 = tail call float @log(float %363)
%365 = load float, float* %5
%366 = fneg float %363
%367 = tail call float @llvm.fmuladd.f32(float %366, float %364, float %365)
store float %367, float* %5
%368 = load i32, i32* %2
br label %369
369: ; preds = %356, %362
%370 = phi i32 [ %357, %356 ], [ %368, %362 ]
%371 = add nuw nsw i64 %358, 1
%372 = sext i32 %370 to i64
%373 = icmp slt i64 %371, %372
br i1 %373, label %356, label %317
}