#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 fmaxf(int, int);
int fminf(int const, int);
int /*<<< orphan*/ query_cache_sizes(int *, int *, int *);
void compute_block_sizes(int *kp, int *mp, int *np, int typesize) {
  int l1, l2, l3;
  query_cache_sizes(&l1, &l2, &l3);
  int k = *kp;
  int m = *mp;
  int n = *np;
  if (fmaxf(k, fmaxf(m, n)) < 50) {
    return;
  }
  int nr = 4;
  int num_reg = 16;
  int mr = num_reg / (2 * nr) * typesize;
  int k_strip = 8;
  int k_div = (mr + nr) * typesize;
  int k_sub = mr * nr * typesize;
  const int max_kc = fmaxf(((l1 - k_sub) / k_div) & (~(k_strip - 1)), 1);
  const int old_k = k;
  if (k > max_kc) {
    k = (k % max_kc) == 0 ? max_kc
                          : max_kc - k_strip * ((max_kc - 1 - (k % max_kc)) /
                                                (k_strip * (k / max_kc + 1)));
  }
  int max_nc;
  const int actual_l2 = 1572864;
  const int lhs_bytes = m * k * typesize;
  const int rest_l1 = l1 - k_sub - lhs_bytes;
  if (rest_l1 >= nr * k * typesize) {
    max_nc = rest_l1 / (k * typesize);
  } else {
    max_nc = (3 * actual_l2) / (4 * max_kc * typesize);
  }
  int nc = (int)(fminf(actual_l2 / (2 * k * typesize), max_nc)) & (~(nr - 1));
  if (n > nc) {
    n = (n % nc == 0) ? nc
                      : (nc - nr * ((nc - (n % nc)) / (nr * (n / nc + 1))));
  } else if (old_k == k) {
    int kn_size = k * n * typesize;
    int actual_lm = actual_l2;
    int max_mc = m;
    if (kn_size < 1024) {
      actual_lm = l1;
    } else if (l3 != 0 && kn_size <= 32768) {
      actual_lm = l2;
      max_mc = fminf(576, max_mc);
    }
    int mc = fminf(actual_lm / (3 * k * typesize), max_mc);
    if (mc > mr) {
      mc -= mc % mr;
    } else if (mc == 0) {
      *kp = k;
      *mp = m;
      *np = n;
      return;
    }
    m = (m % mc == 0) ? mc
                      : (mc - mr * ((mc - (m % mc)) / (mr * (m / mc + 1))));
  }
  *kp = k;
  *mp = m;
  *np = n;
  return;
}


x86 assembly (clang, -O0):
<compute_block_sizes>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
lea    -0x20(%rbp),%rdi
lea    -0x24(%rbp),%rsi
lea    -0x28(%rbp),%rdx
call   1040 <query_cache_sizes@plt>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x30(%rbp),%edi
mov    -0x34(%rbp),%esi
call   1050 <fmaxf@plt>
mov    -0x7c(%rbp),%edi
mov    %eax,%esi
call   1050 <fmaxf@plt>
cmp    $0x32,%eax
jge    119f <compute_block_sizes+0x6f>
jmp    1526 <compute_block_sizes+0x3f6>
movl   $0x4,-0x38(%rbp)
movl   $0x10,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
cltd
idiv   %ecx
imul   -0x1c(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x8,-0x44(%rbp)
mov    -0x40(%rbp),%eax
add    -0x38(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x40(%rbp),%eax
imul   -0x38(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x20(%rbp),%eax
sub    -0x4c(%rbp),%eax
cltd
idivl  -0x48(%rbp)
mov    %eax,%edi
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
xor    $0xffffffff,%eax
and    %eax,%edi
mov    $0x1,%esi
call   1050 <fmaxf@plt>
mov    %eax,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jle    1291 <compute_block_sizes+0x161>
mov    -0x2c(%rbp),%eax
cltd
idivl  -0x50(%rbp)
cmp    $0x0,%edx
jne    1233 <compute_block_sizes+0x103>
mov    -0x50(%rbp),%eax
mov    %eax,-0x80(%rbp)
jmp    128b <compute_block_sizes+0x15b>
mov    -0x50(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x50(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x8c(%rbp)
mov    -0x2c(%rbp),%eax
cltd
idivl  -0x50(%rbp)
mov    -0x8c(%rbp),%eax
sub    %edx,%eax
mov    %eax,-0x88(%rbp)
mov    -0x44(%rbp),%esi
mov    -0x2c(%rbp),%eax
cltd
idivl  -0x50(%rbp)
mov    %eax,%edx
mov    -0x88(%rbp),%eax
add    $0x1,%edx
imul   %edx,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x84(%rbp),%eax
imul   %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x180000,-0x5c(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x2c(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x20(%rbp),%eax
sub    -0x4c(%rbp),%eax
sub    -0x60(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x38(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jl     12dd <compute_block_sizes+0x1ad>
mov    -0x64(%rbp),%eax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
cltd
idiv   %ecx
mov    %eax,-0x58(%rbp)
jmp    12f2 <compute_block_sizes+0x1c2>
mov    -0x50(%rbp),%ecx
shl    $0x2,%ecx
imul   -0x1c(%rbp),%ecx
mov    $0x480000,%eax
cltd
idiv   %ecx
mov    %eax,-0x58(%rbp)
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x1c(%rbp),%ecx
mov    $0x180000,%eax
cltd
idiv   %ecx
mov    %eax,%edi
mov    -0x58(%rbp),%esi
call   1030 <fminf@plt>
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
xor    $0xffffffff,%ecx
and    %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x68(%rbp),%eax
jle    13ac <compute_block_sizes+0x27c>
mov    -0x34(%rbp),%eax
cltd
idivl  -0x68(%rbp)
cmp    $0x0,%edx
jne    1346 <compute_block_sizes+0x216>
mov    -0x68(%rbp),%eax
mov    %eax,-0x90(%rbp)
jmp    139e <compute_block_sizes+0x26e>
mov    -0x68(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x68(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x34(%rbp),%eax
cltd
idivl  -0x68(%rbp)
mov    -0x9c(%rbp),%eax
sub    %edx,%eax
mov    %eax,-0x98(%rbp)
mov    -0x38(%rbp),%esi
mov    -0x34(%rbp),%eax
cltd
idivl  -0x68(%rbp)
mov    %eax,%edx
mov    -0x98(%rbp),%eax
add    $0x1,%edx
imul   %edx,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x94(%rbp),%eax
imul   %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    150b <compute_block_sizes+0x3db>
mov    -0x54(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jne    1506 <compute_block_sizes+0x3d6>
mov    -0x2c(%rbp),%eax
imul   -0x34(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
movl   $0x180000,-0x70(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x74(%rbp)
cmpl   $0x400,-0x6c(%rbp)
jge    13eb <compute_block_sizes+0x2bb>
mov    -0x20(%rbp),%eax
mov    %eax,-0x70(%rbp)
jmp    141d <compute_block_sizes+0x2ed>
cmpl   $0x0,-0x28(%rbp)
je     1418 <compute_block_sizes+0x2e8>
cmpl   $0x8000,-0x6c(%rbp)
jg     1418 <compute_block_sizes+0x2e8>
mov    -0x24(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x74(%rbp),%esi
mov    $0x240,%edi
call   1030 <fminf@plt>
mov    %eax,-0x74(%rbp)
jmp    141d <compute_block_sizes+0x2ed>
mov    -0x70(%rbp),%eax
imul   $0x3,-0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    -0x74(%rbp),%esi
call   1030 <fminf@plt>
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x40(%rbp),%eax
jle    1458 <compute_block_sizes+0x328>
mov    -0x78(%rbp),%eax
cltd
idivl  -0x40(%rbp)
mov    -0x78(%rbp),%eax
sub    %edx,%eax
mov    %eax,-0x78(%rbp)
jmp    1487 <compute_block_sizes+0x357>
cmpl   $0x0,-0x78(%rbp)
jne    1482 <compute_block_sizes+0x352>
mov    -0x2c(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x34(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
jmp    1526 <compute_block_sizes+0x3f6>
jmp    1487 <compute_block_sizes+0x357>
mov    -0x30(%rbp),%eax
cltd
idivl  -0x78(%rbp)
cmp    $0x0,%edx
jne    14a5 <compute_block_sizes+0x375>
mov    -0x78(%rbp),%eax
mov    %eax,-0xa0(%rbp)
jmp    14fd <compute_block_sizes+0x3cd>
mov    -0x78(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x40(%rbp),%ecx
mov    -0x78(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0x30(%rbp),%eax
cltd
idivl  -0x78(%rbp)
mov    -0xac(%rbp),%eax
sub    %edx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0x40(%rbp),%esi
mov    -0x30(%rbp),%eax
cltd
idivl  -0x78(%rbp)
mov    %eax,%edx
mov    -0xa8(%rbp),%eax
add    $0x1,%edx
imul   %edx,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0xa4(%rbp),%eax
imul   %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    150b <compute_block_sizes+0x3db>
mov    -0x2c(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x34(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<compute_block_sizes>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rcx,0x30(%rsp)
mov    %rdx,%r12
mov    %rsi,%rbp
mov    %rdi,%r14
lea    0xc(%rsp),%rdi
lea    0x24(%rsp),%rsi
lea    0x20(%rsp),%rdx
call   1040 <query_cache_sizes@plt>
mov    (%r14),%ebx
mov    0x0(%rbp),%r15d
mov    (%r12),%r13d
mov    %r15d,%edi
mov    %r13d,%esi
call   1050 <fmaxf@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1050 <fmaxf@plt>
cmp    $0x32,%eax
jl     1373 <compute_block_sizes+0x243>
mov    %r13d,0x8(%rsp)
mov    %r15d,0x4(%rsp)
mov    %r14,0x10(%rsp)
mov    %rbp,0x18(%rsp)
mov    %r12,0x28(%rsp)
mov    0x30(%rsp),%r14
lea    (%r14,%r14,1),%ecx
add    $0x4,%ecx
imul   %r14d,%ecx
mov    %r14d,%r12d
imul   %r14d,%r12d
shl    $0x3,%r12d
mov    0xc(%rsp),%eax
sub    %r12d,%eax
cltd
idiv   %ecx
and    $0xfffffff8,%eax
mov    %eax,%edi
mov    $0x1,%esi
call   1050 <fmaxf@plt>
mov    %eax,%ecx
mov    %ebx,%r15d
cmp    %eax,%ebx
jle    1203 <compute_block_sizes+0xd3>
mov    %ebx,%eax
cltd
idiv   %ecx
mov    %ecx,%r15d
test   %edx,%edx
je     1203 <compute_block_sizes+0xd3>
not    %edx
add    %ecx,%edx
lea    0x8(,%rax,8),%esi
mov    %edx,%eax
cltd
idiv   %esi
shl    $0x3,%eax
mov    %ecx,%r15d
sub    %eax,%r15d
mov    %r15d,%edi
imul   %r14d,%edi
mov    %edi,%edx
imul   0x4(%rsp),%edx
mov    0xc(%rsp),%eax
add    %edx,%r12d
sub    %r12d,%eax
lea    0x0(,%rdi,4),%edx
cmp    %edx,%eax
jge    123b <compute_block_sizes+0x10b>
mov    %r14,%r13
imul   %r14d,%ecx
shl    $0x2,%ecx
mov    $0x480000,%eax
xor    %edx,%edx
idiv   %ecx
jmp    1241 <compute_block_sizes+0x111>
mov    %r14,%r13
cltd
idiv   %edi
mov    %eax,%esi
mov    0x18(%rsp),%r12
mov    0x10(%rsp),%rbp
add    %edi,%edi
mov    $0x180000,%eax
xor    %edx,%edx
idiv   %edi
mov    %eax,%edi
call   1030 <fminf@plt>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
mov    0x8(%rsp),%edx
cmp    %ecx,%edx
jle    1291 <compute_block_sizes+0x161>
mov    %edx,%eax
cltd
idiv   %ecx
test   %edx,%edx
je     12c4 <compute_block_sizes+0x194>
mov    %ecx,%esi
sub    %edx,%esi
lea    0x4(,%rax,4),%edi
mov    %esi,%eax
cltd
idiv   %edi
shl    $0x2,%eax
sub    %eax,%ecx
mov    %ecx,%edx
jmp    1360 <compute_block_sizes+0x230>
cmp    %r15d,%ebx
jne    1360 <compute_block_sizes+0x230>
mov    %ebx,%eax
mov    %ebx,%r12d
imul   %r13d,%r12d
add    %r13d,%r13d
mov    %r12d,%eax
imul   %edx,%eax
cmp    $0x3ff,%eax
mov    %r13,%r14
jg     12cb <compute_block_sizes+0x19b>
mov    0xc(%rsp),%ebp
mov    0x4(%rsp),%r13d
mov    %r13d,%esi
jmp    12f9 <compute_block_sizes+0x1c9>
mov    %ecx,%edx
jmp    1360 <compute_block_sizes+0x230>
cmpl   $0x0,0x20(%rsp)
mov    $0x180000,%ebp
je     12ba <compute_block_sizes+0x18a>
mov    0x4(%rsp),%r13d
mov    %r13d,%esi
cmp    $0x8000,%eax
ja     12f9 <compute_block_sizes+0x1c9>
mov    0x24(%rsp),%ebp
mov    $0x240,%edi
mov    %r13d,%esi
call   1030 <fminf@plt>
mov    %eax,%esi
lea    (%r12,%r12,2),%ecx
mov    %ebp,%eax
cltd
idiv   %ecx
mov    %eax,%edi
call   1030 <fminf@plt>
mov    %eax,%ecx
mov    %r14,%rsi
cmp    %esi,%eax
jle    131b <compute_block_sizes+0x1eb>
mov    %ecx,%eax
cltd
idiv   %esi
sub    %edx,%ecx
jmp    131f <compute_block_sizes+0x1ef>
test   %ecx,%ecx
je     134f <compute_block_sizes+0x21f>
mov    %r13d,%eax
cltd
idiv   %ecx
test   %edx,%edx
mov    0x18(%rsp),%r12
mov    0x10(%rsp),%rbp
je     1349 <compute_block_sizes+0x219>
mov    %eax,%esi
mov    %ecx,%eax
sub    %edx,%eax
add    $0x1,%esi
imul   %r14d,%esi
cltd
idiv   %esi
imul   %r14d,%eax
sub    %eax,%ecx
mov    %ecx,0x4(%rsp)
jmp    135c <compute_block_sizes+0x22c>
mov    %ebx,%r15d
mov    0x18(%rsp),%r12
mov    0x10(%rsp),%rbp
mov    0x8(%rsp),%edx
mov    %r15d,0x0(%rbp)
mov    0x4(%rsp),%eax
mov    %eax,(%r12)
mov    0x28(%rsp),%rax
mov    %edx,(%rax)
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @compute_block_sizes(i32* nocapture %0, i32* nocapture %1, i32* nocapture %2, i32 %3) {
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = bitcast i32* %5 to i8*
%9 = bitcast i32* %6 to i8*
%10 = bitcast i32* %7 to i8*
%11 = call i32 @query_cache_sizes(i32* %5, i32* %6, i32* %7)
%12 = load i32, i32* %0
%13 = load i32, i32* %1
%14 = load i32, i32* %2
%15 = call i32 @fmaxf(i32 %13, i32 %14)
%16 = call i32 @fmaxf(i32 %12, i32 %15)
%17 = icmp slt i32 %16, 50
br i1 %17, label %119, label %18
18: ; preds = %4
%19 = shl nsw i32 %3, 1
%20 = add nsw i32 %19, 4
%21 = mul nsw i32 %20, %3
%22 = shl nsw i32 %3, 3
%23 = mul nsw i32 %22, %3
%24 = load i32, i32* %5
%25 = sub nsw i32 %24, %23
%26 = sdiv i32 %25, %21
%27 = and i32 %26, -8
%28 = call i32 @fmaxf(i32 %27, i32 1)
%29 = icmp sgt i32 %12, %28
br i1 %29, label %30, label %42
30: ; preds = %18
%31 = srem i32 %12, %28
%32 = sdiv i32 %12, %28
%33 = icmp eq i32 %31, 0
br i1 %33, label %42, label %34
34: ; preds = %30
%35 = xor i32 %31, -1
%36 = add i32 %28, %35
%37 = shl i32 %32, 3
%38 = add i32 %37, 8
%39 = sdiv i32 %36, %38
%40 = mul i32 %39, -8
%41 = add i32 %40, %28
br label %42
42: ; preds = %34, %30, %18
%43 = phi i32 [ %12, %18 ], [ %41, %34 ], [ %28, %30 ]
%44 = mul i32 %43, %3
%45 = mul i32 %44, %13
%46 = load i32, i32* %5
%47 = add i32 %23, %45
%48 = sub i32 %46, %47
%49 = shl i32 %44, 2
%50 = icmp slt i32 %48, %49
br i1 %50, label %53, label %51
51: ; preds = %42
%52 = sdiv i32 %48, %44
br label %57
53: ; preds = %42
%54 = shl i32 %3, 2
%55 = mul i32 %54, %28
%56 = sdiv i32 4718592, %55
br label %57
57: ; preds = %53, %51
%58 = phi i32 [ %52, %51 ], [ %56, %53 ]
%59 = shl i32 %44, 1
%60 = sdiv i32 1572864, %59
%61 = call i32 @fminf(i32 %60, i32 %58)
%62 = and i32 %61, -4
%63 = icmp sgt i32 %14, %62
br i1 %63, label %64, label %75
64: ; preds = %57
%65 = srem i32 %14, %62
%66 = sdiv i32 %14, %62
%67 = icmp eq i32 %65, 0
br i1 %67, label %115, label %68
68: ; preds = %64
%69 = sub nsw i32 %62, %65
%70 = shl i32 %66, 2
%71 = add i32 %70, 4
%72 = sdiv i32 %69, %71
%73 = mul i32 %72, -4
%74 = add i32 %73, %62
br label %115
75: ; preds = %57
%76 = icmp eq i32 %12, %43
br i1 %76, label %77, label %115
77: ; preds = %75
%78 = mul i32 %12, %3
%79 = mul i32 %78, %14
%80 = icmp slt i32 %79, 1024
br i1 %80, label %81, label %83
81: ; preds = %77
%82 = load i32, i32* %5
br label %91
83: ; preds = %77
%84 = load i32, i32* %7
%85 = icmp ne i32 %84, 0
%86 = icmp ult i32 %79, 32769
%87 = select i1 %85, i1 %86, i1 false
br i1 %87, label %88, label %91
88: ; preds = %83
%89 = load i32, i32* %6
%90 = call i32 @fminf(i32 576, i32 %13)
br label %91
91: ; preds = %83, %88, %81
%92 = phi i32 [ %82, %81 ], [ %89, %88 ], [ 1572864, %83 ]
%93 = phi i32 [ %13, %81 ], [ %90, %88 ], [ %13, %83 ]
%94 = mul i32 %78, 3
%95 = sdiv i32 %92, %94
%96 = call i32 @fminf(i32 %95, i32 %93)
%97 = icmp sgt i32 %96, %19
br i1 %97, label %98, label %101
98: ; preds = %91
%99 = srem i32 %96, %19
%100 = sub nsw i32 %96, %99
br label %103
101: ; preds = %91
%102 = icmp eq i32 %96, 0
br i1 %102, label %115, label %103
103: ; preds = %101, %98
%104 = phi i32 [ %100, %98 ], [ %96, %101 ]
%105 = srem i32 %13, %104
%106 = sdiv i32 %13, %104
%107 = icmp eq i32 %105, 0
br i1 %107, label %115, label %108
108: ; preds = %103
%109 = sub nsw i32 %104, %105
%110 = add nsw i32 %106, 1
%111 = mul nsw i32 %110, %19
%112 = sdiv i32 %109, %111
%113 = mul nsw i32 %112, %19
%114 = sub nsw i32 %104, %113
br label %115
115: ; preds = %75, %64, %68, %103, %108, %101
%116 = phi i32 [ %12, %101 ], [ %43, %108 ], [ %43, %103 ], [ %43, %68 ], [ %43, %64 ], [ %43, %75 ]
%117 = phi i32 [ %13, %101 ], [ %114, %108 ], [ %104, %103 ], [ %13, %68 ], [ %13, %64 ], [ %13, %75 ]
%118 = phi i32 [ %14, %101 ], [ %14, %108 ], [ %14, %103 ], [ %74, %68 ], [ %62, %64 ], [ %14, %75 ]
store i32 %116, i32* %0
store i32 %117, i32* %1
store i32 %118, i32* %2
br label %119
119: ; preds = %115, %4
ret void
}