#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 abs(int);
scalar_t__ bit_weight(unsigned int);
unsigned int *calloc(int, int);
int /*<<< orphan*/ free(unsigned int *);
int eaf2_ks_stat(int *data, int nvars, int npoints) {
  int i, j, k, l, maxd = 0, d, cols;
  const int block = 8192 / 2;
  unsigned *dmap, *c, *mask;
  cols = (nvars - 1) / (8 * sizeof(unsigned)) + 1;
  dmap = calloc(npoints, cols * sizeof(unsigned));
  c = calloc(cols, sizeof(unsigned));
  mask = calloc(cols, sizeof(unsigned));
  for (j = 0; j < cols; j++)
    for (k = 0; k < (8 * sizeof(unsigned)) &&
                (l = j * (8 * sizeof(unsigned)) + k) < nvars / 2;
         k++)
      mask[j] |= (1 << k);
  for (i = 0; i < npoints; i++) {
    for (j = 0; j < cols; j++)
      for (k = 0; k < (8 * sizeof(unsigned)) &&
                  (l = j * (8 * sizeof(unsigned)) + k) < nvars;
           k++)
        dmap[i * cols + j] |= (data[i * nvars + l] != 0) << k;
  }
  for (l = 0; l < npoints; l += block) {
    for (i = l; i < npoints; i++) {
      for (j = l; j < (l + block) && j <= i; j++) {
        d = 0;
        for (k = 0; k < cols; k++) {
          c[k] = dmap[i * cols + k] & dmap[j * cols + k];
          d += bit_weight(c[k] & mask[k]) - bit_weight(c[k] & ~mask[k]);
        }
        if (maxd < abs(d))
          maxd = abs(d);
      }
    }
  }
  free(dmap);
  free(c);
  free(mask);
  return maxd;
}


x86 assembly (clang, -O0):
<eaf2_ks_stat>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x1000,-0x30(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
cltq
shr    $0x5,%rax
add    $0x1,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%edi
movslq -0x2c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%esi
call   1060 <calloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    124e <eaf2_ks_stat+0x10e>
movl   $0x0,-0x1c(%rbp)
movslq -0x1c(%rbp),%rcx
xor    %eax,%eax
cmp    $0x20,%rcx
mov    %al,-0x49(%rbp)
jae    1205 <eaf2_ks_stat+0xc5>
movslq -0x18(%rbp),%rax
shl    $0x5,%rax
movslq -0x1c(%rbp),%rcx
add    %rcx,%rax
mov    %eax,-0x50(%rbp)
mov    %eax,-0x20(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x50(%rbp),%eax
cmp    %ecx,%eax
setl   %al
mov    %al,-0x49(%rbp)
mov    -0x49(%rbp),%al
test   $0x1,%al
jne    1215 <eaf2_ks_stat+0xd5>
jmp    123b <eaf2_ks_stat+0xfb>
mov    -0x1c(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    -0x48(%rbp),%rax
movslq -0x18(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11c5 <eaf2_ks_stat+0x85>
jmp    1240 <eaf2_ks_stat+0x100>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11b2 <eaf2_ks_stat+0x72>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1326 <eaf2_ks_stat+0x1e6>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1313 <eaf2_ks_stat+0x1d3>
movl   $0x0,-0x1c(%rbp)
movslq -0x1c(%rbp),%rcx
xor    %eax,%eax
cmp    $0x20,%rcx
mov    %al,-0x51(%rbp)
jae    12a9 <eaf2_ks_stat+0x169>
movslq -0x18(%rbp),%rax
shl    $0x5,%rax
movslq -0x1c(%rbp),%rcx
add    %rcx,%rax
mov    %eax,-0x20(%rbp)
cmp    -0xc(%rbp),%eax
setl   %al
mov    %al,-0x51(%rbp)
mov    -0x51(%rbp),%al
test   $0x1,%al
jne    12b9 <eaf2_ks_stat+0x179>
jmp    1300 <eaf2_ks_stat+0x1c0>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
setne  %al
and    $0x1,%al
movzbl %al,%edx
mov    -0x1c(%rbp),%ecx
shl    %cl,%edx
mov    -0x38(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    127b <eaf2_ks_stat+0x13b>
jmp    1305 <eaf2_ks_stat+0x1c5>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1268 <eaf2_ks_stat+0x128>
jmp    1318 <eaf2_ks_stat+0x1d8>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1255 <eaf2_ks_stat+0x115>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1492 <eaf2_ks_stat+0x352>
mov    -0x20(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    147d <eaf2_ks_stat+0x33d>
mov    -0x20(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
add    $0x1000,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x52(%rbp)
jge    1376 <eaf2_ks_stat+0x236>
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
setle  %al
mov    %al,-0x52(%rbp)
mov    -0x52(%rbp),%al
test   $0x1,%al
jne    1386 <eaf2_ks_stat+0x246>
jmp    146a <eaf2_ks_stat+0x32a>
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1431 <eaf2_ks_stat+0x2f1>
mov    -0x38(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
and    (%rax,%rcx,4),%edx
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x48(%rbp),%rax
movslq -0x1c(%rbp),%rcx
and    (%rax,%rcx,4),%edi
call   1050 <bit_weight@plt>
mov    %rax,-0x60(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x48(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
xor    $0xffffffff,%eax
and    %eax,%edi
call   1050 <bit_weight@plt>
mov    -0x60(%rbp),%rcx
sub    %rax,%rcx
movslq -0x28(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1394 <eaf2_ks_stat+0x254>
mov    -0x24(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x28(%rbp),%edi
call   1040 <abs@plt>
mov    %eax,%ecx
mov    -0x64(%rbp),%eax
cmp    %ecx,%eax
jge    1457 <eaf2_ks_stat+0x317>
mov    -0x28(%rbp),%edi
call   1040 <abs@plt>
mov    %eax,-0x24(%rbp)
jmp    145c <eaf2_ks_stat+0x31c>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1351 <eaf2_ks_stat+0x211>
jmp    146f <eaf2_ks_stat+0x32f>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    133f <eaf2_ks_stat+0x1ff>
jmp    1482 <eaf2_ks_stat+0x342>
mov    -0x20(%rbp),%eax
add    $0x1000,%eax
mov    %eax,-0x20(%rbp)
jmp    132d <eaf2_ks_stat+0x1ed>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x24(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<eaf2_ks_stat>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %edx,%r15d
mov    %esi,%ebp
mov    %rdi,%r13
lea    -0x1(%rbp),%r14d
sar    $0x5,%r14d
lea    0x1(%r14),%ebx
lea    0x4(,%r14,4),%esi
mov    %edx,%edi
call   1050 <calloc@plt>
mov    %rax,0x28(%rsp)
mov    %ebx,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%r12
mov    %ebx,0x8(%rsp)
mov    %ebx,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%rbx
mov    %rbp,0x20(%rsp)
test   %ebp,%ebp
jle    1211 <eaf2_ks_stat+0xe1>
mov    0x20(%rsp),%rax
mov    %eax,%edx
shr    %edx
xor    %esi,%esi
test   %r14d,%r14d
mov    $0x0,%r8d
cmovg  %r14d,%r8d
add    $0x1,%r8d
mov    $0x1,%r9d
jmp    11cd <eaf2_ks_stat+0x9d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rsi
add    $0x20,%r9d
cmp    %r8,%rsi
je     1211 <eaf2_ks_stat+0xe1>
mov    %r9d,%ebp
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    -0x1(%rbp),%ecx
cmp    %edx,%ecx
jge    11c0 <eaf2_ks_stat+0x90>
mov    $0x1,%edi
mov    %eax,%ecx
shl    %cl,%edi
or     %edi,(%rbx,%rsi,4)
cmp    %edx,%ebp
jge    11c0 <eaf2_ks_stat+0x90>
lea    0x1(%rax),%ecx
mov    $0x1,%edi
shl    %cl,%edi
or     %edi,(%rbx,%rsi,4)
add    $0x2,%ebp
add    $0x2,%eax
cmp    $0x20,%eax
jne    11e0 <eaf2_ks_stat+0xb0>
jmp    11c0 <eaf2_ks_stat+0x90>
test   %r15d,%r15d
mov    %rbx,0x58(%rsp)
jle    14ed <eaf2_ks_stat+0x3bd>
mov    %r12,0x38(%rsp)
movslq 0x20(%rsp),%r9
xor    %r11d,%r11d
test   %r14d,%r14d
mov    %r14,%rax
mov    $0x0,%r14d
mov    %rax,0x40(%rsp)
cmovg  %eax,%r14d
add    $0x1,%r14d
movslq 0x8(%rsp),%rax
mov    %rax,0x30(%rsp)
mov    %r15d,0x18(%rsp)
mov    %r15d,%eax
mov    %rax,0x8(%rsp)
add    $0x4,%r13
lea    0x0(,%r9,4),%r10
jmp    1282 <eaf2_ks_stat+0x152>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r11
add    %r10,%r13
cmp    0x8(%rsp),%r11
je     131f <eaf2_ks_stat+0x1ef>
cmpl   $0x0,0x20(%rsp)
jle    1270 <eaf2_ks_stat+0x140>
mov    %r11,%r15
imul   0x30(%rsp),%r15
mov    $0x1,%ebx
xor    %edx,%edx
mov    %r13,%rdi
xor    %r12d,%r12d
jmp    12c5 <eaf2_ks_stat+0x195>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
sub    $0xffffffffffffff80,%rdi
add    $0x20,%rbx
add    $0x20,%rdx
cmp    %r14,%r12
je     1270 <eaf2_ks_stat+0x140>
lea    (%r12,%r15,1),%rbp
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
lea    (%rdx,%rax,1),%rcx
cmp    %r9,%rcx
jge    12b0 <eaf2_ks_stat+0x180>
xor    %r8d,%r8d
cmpl   $0x0,-0x4(%rdi,%rax,4)
setne  %r8b
mov    %eax,%ecx
shl    %cl,%r8d
mov    0x28(%rsp),%rcx
or     %r8d,(%rcx,%rbp,4)
lea    (%rbx,%rax,1),%rcx
cmp    %r9,%rcx
jge    12b0 <eaf2_ks_stat+0x180>
xor    %esi,%esi
cmpl   $0x0,(%rdi,%rax,4)
setne  %sil
lea    0x1(%rax),%ecx
shl    %cl,%esi
mov    0x28(%rsp),%rcx
or     %esi,(%rcx,%rbp,4)
add    $0x2,%rax
cmp    $0x20,%rax
jne    12d0 <eaf2_ks_stat+0x1a0>
jmp    12b0 <eaf2_ks_stat+0x180>
mov    0x18(%rsp),%eax
test   %eax,%eax
jle    14f1 <eaf2_ks_stat+0x3c1>
xor    %ecx,%ecx
mov    0x40(%rsp),%r14
test   %r14d,%r14d
cmovle %ecx,%r14d
add    $0x1,%r14d
mov    0x30(%rsp),%rdx
lea    -0x1(%rdx),%rcx
shl    $0xe,%rcx
add    $0x4000,%rcx
mov    %rcx,0x60(%rsp)
lea    -0x4(,%rdx,4),%rcx
ff
add    $0x4,%rcx
mov    %rcx,0x50(%rsp)
movl   $0x1,0x14(%rsp)
mov    0x28(%rsp),%rdx
mov    %eax,0x1c(%rsp)
xor    %eax,%eax
xor    %ebx,%ebx
mov    0x38(%rsp),%r12
mov    %r14,0x40(%rsp)
jmp    13bc <eaf2_ks_stat+0x28c>
nopl   0x0(%rax,%rax,1)
mov    0x48(%rsp),%rcx
add    $0x1000,%rcx
addl   $0x1000,0x14(%rsp)
addl   $0xfffff000,0x1c(%rsp)
ff
add    0x60(%rsp),%rdx
cmp    %eax,%ecx
mov    %rcx,%rax
jge    14f8 <eaf2_ks_stat+0x3c8>
mov    %rdx,%rcx
mov    %rax,0x48(%rsp)
mov    %rax,%rsi
movl   $0x0,0x4(%rsp)
mov    %rdx,0x68(%rsp)
jmp    13fe <eaf2_ks_stat+0x2ce>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rsi
mov    0x4(%rsp),%eax
add    $0x1,%eax
add    0x50(%rsp),%rcx
mov    %eax,0x4(%rsp)
cmp    0x1c(%rsp),%eax
mov    0x18(%rsp),%eax
je     1390 <eaf2_ks_stat+0x260>
mov    0x48(%rsp),%rax
cmp    %rsi,%rax
ja     13e0 <eaf2_ks_stat+0x2b0>
mov    0x4(%rsp),%edi
cmp    $0xfff,%edi
mov    $0xfff,%ebp
cmovb  %edi,%ebp
add    0x14(%rsp),%ebp
mov    %rbp,0x70(%rsp)
mov    %rdx,%rdi
mov    %rsi,0x78(%rsp)
jmp    1468 <eaf2_ks_stat+0x338>
nopl   (%rax)
xor    %ebp,%ebp
mov    %ebp,%eax
neg    %eax
cmovs  %ebp,%eax
mov    0x30(%rsp),%ebx
cmp    %eax,%ebx
cmovl  %eax,%ebx
mov    0x80(%rsp),%rax
add    $0x1,%rax
add    0x50(%rsp),%rdi
cmp    0x70(%rsp),%rax
mov    0x68(%rsp),%rdx
mov    0x78(%rsp),%rsi
je     13e0 <eaf2_ks_stat+0x2b0>
cmpl   $0x0,0x20(%rsp)
mov    %ebx,0x30(%rsp)
mov    %rax,0x80(%rsp)
jle    1430 <eaf2_ks_stat+0x300>
xor    %ebx,%ebx
xor    %ebp,%ebp
mov    %rdi,0x8(%rsp)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rdi,%rbx,4),%r13d
and    (%rcx,%rbx,4),%r13d
mov    %r13d,(%r12,%rbx,4)
mov    0x58(%rsp),%rax
mov    (%rax,%rbx,4),%r14d
mov    %r14d,%edi
and    %r13d,%edi
mov    %rcx,%r12
call   1040 <bit_weight@plt>
mov    %rax,%r15
not    %r14d
and    %r13d,%r14d
mov    %r14d,%edi
mov    0x40(%rsp),%r14
mov    0x38(%rsp),%r13
call   1040 <bit_weight@plt>
mov    0x8(%rsp),%rdi
mov    %r12,%rcx
mov    %r13,%r12
sub    %eax,%r15d
add    %r15d,%ebp
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1490 <eaf2_ks_stat+0x360>
jmp    1432 <eaf2_ks_stat+0x302>
xor    %ebx,%ebx
jmp    14f8 <eaf2_ks_stat+0x3c8>
xor    %ebx,%ebx
mov    0x38(%rsp),%r12
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x58(%rsp),%rdi
call   1030 <free@plt>
mov    %ebx,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @eaf2_ks_stat(i32* %0, i32 %1, i32 %2) {
%4 = alloca i32*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32*
%16 = alloca i32*
%17 = alloca i32*
store i32* %0, i32** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
store i32 0, i32* %11
store i32 4096, i32* %14
%18 = load i32, i32* %5
%19 = sub nsw i32 %18, 1
%20 = sext i32 %19 to i64
%21 = udiv i64 %20, 32
%22 = add i64 %21, 1
%23 = trunc i64 %22 to i32
store i32 %23, i32* %13
%24 = load i32, i32* %6
%25 = load i32, i32* %13
%26 = sext i32 %25 to i64
%27 = mul i64 %26, 4
%28 = trunc i64 %27 to i32
%29 = call i32* @calloc(i32 %24, i32 %28)
store i32* %29, i32** %15
%30 = load i32, i32* %13
%31 = call i32* @calloc(i32 %30, i32 4)
store i32* %31, i32** %16
%32 = load i32, i32* %13
%33 = call i32* @calloc(i32 %32, i32 4)
store i32* %33, i32** %17
store i32 0, i32* %8
br label %34
34: ; preds = %69, %3
%35 = load i32, i32* %8
%36 = load i32, i32* %13
%37 = icmp slt i32 %35, %36
br i1 %37, label %38, label %72
38: ; preds = %34
store i32 0, i32* %9
br label %39
39: ; preds = %65, %38
%40 = load i32, i32* %9
%41 = sext i32 %40 to i64
%42 = icmp ult i64 %41, 32
br i1 %42, label %43, label %54
43: ; preds = %39
%44 = load i32, i32* %8
%45 = sext i32 %44 to i64
%46 = mul i64 %45, 32
%47 = load i32, i32* %9
%48 = sext i32 %47 to i64
%49 = add i64 %46, %48
%50 = trunc i64 %49 to i32
store i32 %50, i32* %10
%51 = load i32, i32* %5
%52 = sdiv i32 %51, 2
%53 = icmp slt i32 %50, %52
br label %54
54: ; preds = %43, %39
%55 = phi i1 [ false, %39 ], [ %53, %43 ]
br i1 %55, label %56, label %68
56: ; preds = %54
%57 = load i32, i32* %9
%58 = shl i32 1, %57
%59 = load i32*, i32** %17
%60 = load i32, i32* %8
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds i32, i32* %59, i64 %61
%63 = load i32, i32* %62
%64 = or i32 %63, %58
store i32 %64, i32* %62
br label %65
65: ; preds = %56
%66 = load i32, i32* %9
%67 = add nsw i32 %66, 1
store i32 %67, i32* %9
br label %39
68: ; preds = %54
br label %69
69: ; preds = %68
%70 = load i32, i32* %8
%71 = add nsw i32 %70, 1
store i32 %71, i32* %8
br label %34
72: ; preds = %34
store i32 0, i32* %7
br label %73
73: ; preds = %131, %72
%74 = load i32, i32* %7
%75 = load i32, i32* %6
%76 = icmp slt i32 %74, %75
br i1 %76, label %77, label %134
77: ; preds = %73
store i32 0, i32* %8
br label %78
78: ; preds = %127, %77
%79 = load i32, i32* %8
%80 = load i32, i32* %13
%81 = icmp slt i32 %79, %80
br i1 %81, label %82, label %130
82: ; preds = %78
store i32 0, i32* %9
br label %83
83: ; preds = %123, %82
%84 = load i32, i32* %9
%85 = sext i32 %84 to i64
%86 = icmp ult i64 %85, 32
br i1 %86, label %87, label %97
87: ; preds = %83
%88 = load i32, i32* %8
%89 = sext i32 %88 to i64
%90 = mul i64 %89, 32
%91 = load i32, i32* %9
%92 = sext i32 %91 to i64
%93 = add i64 %90, %92
%94 = trunc i64 %93 to i32
store i32 %94, i32* %10
%95 = load i32, i32* %5
%96 = icmp slt i32 %94, %95
br label %97
97: ; preds = %87, %83
%98 = phi i1 [ false, %83 ], [ %96, %87 ]
br i1 %98, label %99, label %126
99: ; preds = %97
%100 = load i32*, i32** %4
%101 = load i32, i32* %7
%102 = load i32, i32* %5
%103 = mul nsw i32 %101, %102
%104 = load i32, i32* %10
%105 = add nsw i32 %103, %104
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds i32, i32* %100, i64 %106
%108 = load i32, i32* %107
%109 = icmp ne i32 %108, 0
%110 = zext i1 %109 to i32
%111 = load i32, i32* %9
%112 = shl i32 %110, %111
%113 = load i32*, i32** %15
%114 = load i32, i32* %7
%115 = load i32, i32* %13
%116 = mul nsw i32 %114, %115
%117 = load i32, i32* %8
%118 = add nsw i32 %116, %117
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds i32, i32* %113, i64 %119
%121 = load i32, i32* %120
%122 = or i32 %121, %112
store i32 %122, i32* %120
br label %123
123: ; preds = %99
%124 = load i32, i32* %9
%125 = add nsw i32 %124, 1
store i32 %125, i32* %9
br label %83
126: ; preds = %97
br label %127
127: ; preds = %126
%128 = load i32, i32* %8
%129 = add nsw i32 %128, 1
store i32 %129, i32* %8
br label %78
130: ; preds = %78
br label %131
131: ; preds = %130
%132 = load i32, i32* %7
%133 = add nsw i32 %132, 1
store i32 %133, i32* %7
br label %73
134: ; preds = %73
store i32 0, i32* %10
br label %135
135: ; preds = %237, %134
%136 = load i32, i32* %10
%137 = load i32, i32* %6
%138 = icmp slt i32 %136, %137
br i1 %138, label %139, label %240
139: ; preds = %135
%140 = load i32, i32* %10
store i32 %140, i32* %7
br label %141
141: ; preds = %233, %139
%142 = load i32, i32* %7
%143 = load i32, i32* %6
%144 = icmp slt i32 %142, %143
br i1 %144, label %145, label %236
145: ; preds = %141
%146 = load i32, i32* %10
store i32 %146, i32* %8
br label %147
147: ; preds = %229, %145
%148 = load i32, i32* %8
%149 = load i32, i32* %10
%150 = add nsw i32 %149, 4096
%151 = icmp slt i32 %148, %150
br i1 %151, label %152, label %156
152: ; preds = %147
%153 = load i32, i32* %8
%154 = load i32, i32* %7
%155 = icmp sle i32 %153, %154
br label %156
156: ; preds = %152, %147
%157 = phi i1 [ false, %147 ], [ %155, %152 ]
br i1 %157, label %158, label %232
158: ; preds = %156
store i32 0, i32* %12
store i32 0, i32* %9
br label %159
159: ; preds = %217, %158
%160 = load i32, i32* %9
%161 = load i32, i32* %13
%162 = icmp slt i32 %160, %161
br i1 %162, label %163, label %220
163: ; preds = %159
%164 = load i32*, i32** %15
%165 = load i32, i32* %7
%166 = load i32, i32* %13
%167 = mul nsw i32 %165, %166
%168 = load i32, i32* %9
%169 = add nsw i32 %167, %168
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds i32, i32* %164, i64 %170
%172 = load i32, i32* %171
%173 = load i32*, i32** %15
%174 = load i32, i32* %8
%175 = load i32, i32* %13
%176 = mul nsw i32 %174, %175
%177 = load i32, i32* %9
%178 = add nsw i32 %176, %177
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds i32, i32* %173, i64 %179
%181 = load i32, i32* %180
%182 = and i32 %172, %181
%183 = load i32*, i32** %16
%184 = load i32, i32* %9
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds i32, i32* %183, i64 %185
store i32 %182, i32* %186
%187 = load i32*, i32** %16
%188 = load i32, i32* %9
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds i32, i32* %187, i64 %189
%191 = load i32, i32* %190
%192 = load i32*, i32** %17
%193 = load i32, i32* %9
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds i32, i32* %192, i64 %194
%196 = load i32, i32* %195
%197 = and i32 %191, %196
%198 = call i64 @bit_weight(i32 %197)
%199 = load i32*, i32** %16
%200 = load i32, i32* %9
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds i32, i32* %199, i64 %201
%203 = load i32, i32* %202
%204 = load i32*, i32** %17
%205 = load i32, i32* %9
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds i32, i32* %204, i64 %206
%208 = load i32, i32* %207
%209 = xor i32 %208, -1
%210 = and i32 %203, %209
%211 = call i64 @bit_weight(i32 %210)
%212 = sub nsw i64 %198, %211
%213 = load i32, i32* %12
%214 = sext i32 %213 to i64
%215 = add nsw i64 %214, %212
%216 = trunc i64 %215 to i32
store i32 %216, i32* %12
br label %217
217: ; preds = %163
%218 = load i32, i32* %9
%219 = add nsw i32 %218, 1
store i32 %219, i32* %9
br label %159
220: ; preds = %159
%221 = load i32, i32* %11
%222 = load i32, i32* %12
%223 = call i32 @abs(i32 %222)
%224 = icmp slt i32 %221, %223
br i1 %224, label %225, label %228
225: ; preds = %220
%226 = load i32, i32* %12
%227 = call i32 @abs(i32 %226)
store i32 %227, i32* %11
br label %228
228: ; preds = %225, %220
br label %229
229: ; preds = %228
%230 = load i32, i32* %8
%231 = add nsw i32 %230, 1
store i32 %231, i32* %8
br label %147
232: ; preds = %156
br label %233
233: ; preds = %232
%234 = load i32, i32* %7
%235 = add nsw i32 %234, 1
store i32 %235, i32* %7
br label %141
236: ; preds = %141
br label %237
237: ; preds = %236
%238 = load i32, i32* %10
%239 = add nsw i32 %238, 4096
store i32 %239, i32* %10
br label %135
240: ; preds = %135
%241 = load i32*, i32** %15
%242 = call i32 @free(i32* %241)
%243 = load i32*, i32** %16
%244 = call i32 @free(i32* %243)
%245 = load i32*, i32** %17
%246 = call i32 @free(i32* %245)
%247 = load i32, i32* %11
ret i32 %247
}

LLVM IR (-O2):
define i32 @eaf2_ks_stat(i32* nocapture %0, i32 %1, i32 %2) {
%4 = add nsw i32 %1, -1
%5 = ashr i32 %4, 5
%6 = add nsw i32 %5, 1
%7 = shl nsw i32 %6, 2
%8 = tail call i32* @calloc(i32 %2, i32 %7)
%9 = tail call i32* @calloc(i32 %6, i32 4)
%10 = tail call i32* @calloc(i32 %6, i32 4)
%11 = icmp slt i32 %1, 1
br i1 %11, label %22, label %12
12: ; preds = %3
%13 = lshr i32 %1, 1
%14 = call i32 @llvm.smax.i32(i32 %5, i32 0)
%15 = add nuw nsw i32 %14, 1
%16 = zext i32 %15 to i64
br label %17
17: ; preds = %12, %48
%18 = phi i64 [ 0, %12 ], [ %49, %48 ]
%19 = trunc i64 %18 to i32
%20 = shl i32 %19, 5
%21 = getelementptr inbounds i32, i32* %10, i64 %18
br label %31
22: ; preds = %48, %3
%23 = icmp sgt i32 %2, 0
br i1 %23, label %24, label %163
24: ; preds = %22
%25 = sext i32 %1 to i64
%26 = call i32 @llvm.smax.i32(i32 %5, i32 0)
%27 = add nuw nsw i32 %26, 1
%28 = sext i32 %6 to i64
%29 = zext i32 %2 to i64
%30 = zext i32 %27 to i64
br label %51
31: ; preds = %42, %17
%32 = phi i32 [ 0, %17 ], [ %46, %42 ]
%33 = add nuw nsw i32 %32, %20
%34 = icmp slt i32 %33, %13
br i1 %34, label %35, label %48
35: ; preds = %31
%36 = shl nuw i32 1, %32
%37 = load i32, i32* %21
%38 = or i32 %37, %36
store i32 %38, i32* %21
%39 = or i32 %32, 1
%40 = add nuw nsw i32 %39, %20
%41 = icmp slt i32 %40, %13
br i1 %41, label %42, label %48
42: ; preds = %35
%43 = shl nuw i32 1, %39
%44 = load i32, i32* %21
%45 = or i32 %44, %43
store i32 %45, i32* %21
%46 = add nuw nsw i32 %32, 2
%47 = icmp eq i32 %46, 32
br i1 %47, label %48, label %31
48: ; preds = %42, %35, %31
%49 = add nuw nsw i64 %18, 1
%50 = icmp eq i64 %49, %16
br i1 %50, label %22, label %17
51: ; preds = %24, %99
%52 = phi i64 [ 0, %24 ], [ %100, %99 ]
br i1 %11, label %99, label %53
53: ; preds = %51
%54 = mul nsw i64 %52, %25
%55 = mul nsw i64 %52, %28
br label %62
56: ; preds = %99
br i1 %23, label %57, label %163
57: ; preds = %56
%58 = call i32 @llvm.smax.i32(i32 %5, i32 0)
%59 = add nuw nsw i32 %58, 1
%60 = sext i32 %6 to i64
%61 = zext i32 %59 to i64
br label %102
62: ; preds = %53, %96
%63 = phi i64 [ 0, %53 ], [ %97, %96 ]
%64 = shl i64 %63, 5
%65 = add nsw i64 %63, %55
%66 = getelementptr inbounds i32, i32* %8, i64 %65
br label %67
67: ; preds = %84, %62
%68 = phi i64 [ 0, %62 ], [ %94, %84 ]
%69 = add nuw nsw i64 %68, %64
%70 = icmp slt i64 %69, %25
br i1 %70, label %71, label %96
71: ; preds = %67
%72 = add nsw i64 %69, %54
%73 = getelementptr inbounds i32, i32* %0, i64 %72
%74 = load i32, i32* %73
%75 = icmp ne i32 %74, 0
%76 = zext i1 %75 to i32
%77 = trunc i64 %68 to i32
%78 = shl nuw i32 %76, %77
%79 = load i32, i32* %66
%80 = or i32 %78, %79
store i32 %80, i32* %66
%81 = or i64 %68, 1
%82 = add nuw nsw i64 %81, %64
%83 = icmp slt i64 %82, %25
br i1 %83, label %84, label %96
84: ; preds = %71
%85 = add nsw i64 %82, %54
%86 = getelementptr inbounds i32, i32* %0, i64 %85
%87 = load i32, i32* %86
%88 = icmp ne i32 %87, 0
%89 = zext i1 %88 to i32
%90 = trunc i64 %81 to i32
%91 = shl nuw i32 %89, %90
%92 = load i32, i32* %66
%93 = or i32 %91, %92
store i32 %93, i32* %66
%94 = add nuw nsw i64 %68, 2
%95 = icmp eq i64 %94, 32
br i1 %95, label %96, label %67
96: ; preds = %84, %71, %67
%97 = add nuw nsw i64 %63, 1
%98 = icmp eq i64 %97, %30
br i1 %98, label %99, label %62
99: ; preds = %96, %51
%100 = add nuw nsw i64 %52, 1
%101 = icmp eq i64 %100, %29
br i1 %101, label %56, label %51
102: ; preds = %157, %57
%103 = phi i32 [ %2, %57 ], [ %162, %157 ]
%104 = phi i32 [ 1, %57 ], [ %161, %157 ]
%105 = phi i64 [ 0, %57 ], [ %158, %157 ]
%106 = phi i32 [ 0, %57 ], [ %153, %157 ]
br label %107
107: ; preds = %102, %152
%108 = phi i64 [ %105, %102 ], [ %154, %152 ]
%109 = phi i32 [ 0, %102 ], [ %155, %152 ]
%110 = phi i32 [ %106, %102 ], [ %153, %152 ]
%111 = icmp ugt i64 %105, %108
br i1 %111, label %152, label %112
112: ; preds = %107
%113 = call i32 @llvm.umin.i32(i32 %109, i32 4095)
%114 = add i32 %104, %113
%115 = mul nsw i64 %108, %60
%116 = zext i32 %114 to i64
br label %117
117: ; preds = %112, %145
%118 = phi i64 [ %105, %112 ], [ %150, %145 ]
%119 = phi i32 [ %110, %112 ], [ %149, %145 ]
br i1 %11, label %145, label %120
120: ; preds = %117
%121 = mul nsw i64 %118, %60
br label %122
122: ; preds = %120, %122
%123 = phi i64 [ 0, %120 ], [ %143, %122 ]
%124 = phi i32 [ 0, %120 ], [ %142, %122 ]
%125 = add nsw i64 %123, %115
%126 = getelementptr inbounds i32, i32* %8, i64 %125
%127 = load i32, i32* %126
%128 = add nsw i64 %123, %121
%129 = getelementptr inbounds i32, i32* %8, i64 %128
%130 = load i32, i32* %129
%131 = and i32 %130, %127
%132 = getelementptr inbounds i32, i32* %9, i64 %123
store i32 %131, i32* %132
%133 = getelementptr inbounds i32, i32* %10, i64 %123
%134 = load i32, i32* %133
%135 = and i32 %134, %131
%136 = tail call i64 @bit_weight(i32 %135)
%137 = xor i32 %134, -1
%138 = and i32 %131, %137
%139 = tail call i64 @bit_weight(i32 %138)
%140 = sub nsw i64 %136, %139
%141 = trunc i64 %140 to i32
%142 = add i32 %124, %141
%143 = add nuw nsw i64 %123, 1
%144 = icmp eq i64 %143, %61
br i1 %144, label %145, label %122
145: ; preds = %122, %117
%146 = phi i32 [ 0, %117 ], [ %142, %122 ]
%147 = tail call i32 @llvm.abs.i32(i32 %146, i1 true)
%148 = icmp slt i32 %119, %147
%149 = select i1 %148, i32 %147, i32 %119
%150 = add nuw i64 %118, 1
%151 = icmp eq i64 %150, %116
br i1 %151, label %152, label %117
152: ; preds = %145, %107
%153 = phi i32 [ %110, %107 ], [ %149, %145 ]
%154 = add nuw i64 %108, 1
%155 = add nuw nsw i32 %109, 1
%156 = icmp eq i32 %155, %103
br i1 %156, label %157, label %107
157: ; preds = %152
%158 = add nuw i64 %105, 4096
%159 = trunc i64 %158 to i32
%160 = icmp slt i32 %159, %2
%161 = add nuw i32 %104, 4096
%162 = add i32 %103, -4096
br i1 %160, label %102, label %163
163: ; preds = %157, %22, %56
%164 = phi i32 [ 0, %56 ], [ 0, %22 ], [ %153, %157 ]
%165 = tail call i32 @free(i32* %8)
%166 = tail call i32 @free(i32* %9)
%167 = tail call i32 @free(i32* %10)
ret i32 %164
}