#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 pow(int, int);
int iond_calc_smx_sizes(int ndim, int *size, int *complex, int *smx_size) {
  int done, i, buffer_size, factor, count;
  int largest, largest_size;
  int smallest, smallest_size;
  int ratio;
  int smx_number[5];
  if (ndim == 1) {
    smx_size[0] = (((8 * 1024) < (size[0])) ? (8 * 1024) : (size[0]));
    return 0;
  }
  smallest = 0;
  smallest_size = size[smallest];
  largest = 0;
  largest_size = size[largest];
  for (i = 0; i < ndim; i++) {
    smx_size[i] = 1;
    smx_number[i] = size[i];
    buffer_size += size[i];
    if (size[i] > largest_size) {
      largest = i;
      largest_size = size[largest];
    }
    if (size[i] < smallest_size) {
      smallest = i;
      smallest_size = size[smallest];
    }
  }
  factor = 1;
  count = 0;
  buffer_size = 0;
  done = 0;
  while (!done) {
    for (i = 0; i < ndim; i++) {
      ratio = (((int)size[i]) / ((int)smallest_size));
      if (ratio > 4)
        ratio = 4;
      smx_size[i] =
          (((32) < (factor * pow(2, ratio))) ? (32) : (factor * pow(2, ratio)));
      smx_size[i] = (((smx_size[i]) > (4)) ? (smx_size[i]) : (4));
      smx_size[i] = (((smx_size[i]) < (size[i])) ? (smx_size[i]) : (size[i]));
    }
    for (i = 0; i < ndim; i++) {
      if (smx_size[i] == 32)
        count++;
      if (smx_size[i] >= size[i]) {
        smx_size[i] = size[i];
        count++;
      }
    }
    if (count == ndim)
      done = 1;
    if (count > ndim) {
      done = 1;
    }
    buffer_size = largest_size;
    for (i = 0; i < ndim; i++) {
      if (i != largest)
        buffer_size *= smx_size[i];
    }
    if ((unsigned int)buffer_size <= (unsigned int)256 * 1024 / sizeof(float))
      factor *= 2;
    else {
      factor /= 2;
      for (i = 0; i < ndim; i++) {
        ratio = (((int)size[i]) / ((int)smallest_size));
        if (ratio > 4)
          ratio = 4;
        smx_size[i] =
            (((32) < (factor * pow(2, ratio))) ? (32)
                                               : (factor * pow(2, ratio)));
        smx_size[i] = (((smx_size[i]) > (4)) ? (smx_size[i]) : (4));
        smx_size[i] = (((smx_size[i]) < (size[i])) ? (smx_size[i]) : (size[i]));
      }
      done = 1;
    }
  }
  return (0);
}


x86 assembly (clang, -O0):
<iond_calc_smx_sizes>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
cmpl   $0x1,-0x8(%rbp)
jne    1170 <iond_calc_smx_sizes+0x60>
mov    -0x10(%rbp),%rcx
mov    $0x2000,%eax
cmp    (%rcx),%eax
jge    1152 <iond_calc_smx_sizes+0x42>
mov    $0x2000,%eax
mov    %eax,-0x64(%rbp)
jmp    115b <iond_calc_smx_sizes+0x4b>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x0,-0x4(%rbp)
jmp    1613 <iond_calc_smx_sizes+0x503>
movl   $0x0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1243 <iond_calc_smx_sizes+0x133>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
movslq -0x28(%rbp),%rax
mov    %ecx,-0x60(%rbp,%rax,4)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x3c(%rbp),%eax
jle    1208 <iond_calc_smx_sizes+0xf8>
mov    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x44(%rbp),%eax
jge    1230 <iond_calc_smx_sizes+0x120>
mov    -0x28(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
jmp    1235 <iond_calc_smx_sizes+0x125>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11a1 <iond_calc_smx_sizes+0x91>
movl   $0x1,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    1275 <iond_calc_smx_sizes+0x165>
jmp    160c <iond_calc_smx_sizes+0x4fc>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13a3 <iond_calc_smx_sizes+0x293>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cltd
idivl  -0x44(%rbp)
mov    %eax,-0x48(%rbp)
cmpl   $0x4,-0x48(%rbp)
jle    12ab <iond_calc_smx_sizes+0x19b>
movl   $0x4,-0x48(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x48(%rbp),%esi
mov    $0x2,%edi
call   1030 <pow@plt>
mov    -0x68(%rbp),%ecx
imul   %eax,%ecx
mov    $0x20,%eax
cmp    %ecx,%eax
jge    12de <iond_calc_smx_sizes+0x1ce>
mov    $0x20,%eax
mov    %eax,-0x6c(%rbp)
jmp    12fc <iond_calc_smx_sizes+0x1ec>
mov    -0x30(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x48(%rbp),%esi
mov    $0x2,%edi
call   1030 <pow@plt>
mov    %eax,%ecx
mov    -0x70(%rbp),%eax
imul   %ecx,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
cmpl   $0x4,(%rax,%rcx,4)
jle    132f <iond_calc_smx_sizes+0x21f>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
jmp    133c <iond_calc_smx_sizes+0x22c>
mov    $0x4,%eax
mov    %eax,-0x74(%rbp)
jmp    133c <iond_calc_smx_sizes+0x22c>
mov    -0x74(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1379 <iond_calc_smx_sizes+0x269>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x78(%rbp)
jmp    1387 <iond_calc_smx_sizes+0x277>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    127c <iond_calc_smx_sizes+0x16c>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    141f <iond_calc_smx_sizes+0x30f>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
cmpl   $0x20,(%rax,%rcx,4)
jne    13d1 <iond_calc_smx_sizes+0x2c1>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jl     140c <iond_calc_smx_sizes+0x2fc>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1411 <iond_calc_smx_sizes+0x301>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13aa <iond_calc_smx_sizes+0x29a>
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jne    1432 <iond_calc_smx_sizes+0x322>
movl   $0x1,-0x24(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jle    1445 <iond_calc_smx_sizes+0x335>
movl   $0x1,-0x24(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    148f <iond_calc_smx_sizes+0x37f>
mov    -0x28(%rbp),%eax
cmp    -0x38(%rbp),%eax
je     147c <iond_calc_smx_sizes+0x36c>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
imul   -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    1481 <iond_calc_smx_sizes+0x371>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1452 <iond_calc_smx_sizes+0x342>
mov    -0x2c(%rbp),%eax
cmp    $0x10000,%rax
ja     14ac <iond_calc_smx_sizes+0x39c>
mov    -0x30(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1607 <iond_calc_smx_sizes+0x4f7>
mov    -0x30(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1600 <iond_calc_smx_sizes+0x4f0>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cltd
idivl  -0x44(%rbp)
mov    %eax,-0x48(%rbp)
cmpl   $0x4,-0x48(%rbp)
jle    14f0 <iond_calc_smx_sizes+0x3e0>
movl   $0x4,-0x48(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x48(%rbp),%esi
mov    $0x2,%edi
call   1030 <pow@plt>
mov    -0x7c(%rbp),%ecx
imul   %eax,%ecx
mov    $0x20,%eax
cmp    %ecx,%eax
jge    1523 <iond_calc_smx_sizes+0x413>
mov    $0x20,%eax
mov    %eax,-0x80(%rbp)
jmp    1547 <iond_calc_smx_sizes+0x437>
mov    -0x30(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x48(%rbp),%esi
mov    $0x2,%edi
call   1030 <pow@plt>
mov    %eax,%ecx
mov    -0x84(%rbp),%eax
imul   %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
cmpl   $0x4,(%rax,%rcx,4)
jle    157d <iond_calc_smx_sizes+0x46d>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x88(%rbp)
jmp    158d <iond_calc_smx_sizes+0x47d>
mov    $0x4,%eax
mov    %eax,-0x88(%rbp)
jmp    158d <iond_calc_smx_sizes+0x47d>
mov    -0x88(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    15d0 <iond_calc_smx_sizes+0x4c0>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x8c(%rbp)
jmp    15e1 <iond_calc_smx_sizes+0x4d1>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14c1 <iond_calc_smx_sizes+0x3b1>
movl   $0x1,-0x24(%rbp)
jmp    125f <iond_calc_smx_sizes+0x14f>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<iond_calc_smx_sizes>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rcx,%rbx
mov    (%rsi),%r10d
cmp    $0x1,%edi
jne    114c <iond_calc_smx_sizes+0x3c>
cmp    $0x2000,%r10d
mov    $0x2000,%eax
cmovl  %r10d,%eax
mov    %eax,(%rbx)
xor    %eax,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rsi,%r14
xor    %ebp,%ebp
mov    %edi,%r8d
test   %edi,%edi
jle    1167 <iond_calc_smx_sizes+0x57>
cmp    $0x1,%edi
jne    1174 <iond_calc_smx_sizes+0x64>
xor    %ecx,%ecx
mov    %r10d,%eax
xor    %r11d,%r11d
jmp    11d7 <iond_calc_smx_sizes+0xc7>
xor    %r11d,%r11d
mov    %r10d,0x14(%rsp)
jmp    1203 <iond_calc_smx_sizes+0xf3>
mov    %r8d,%r9d
and    $0xfffffffe,%r9d
xor    %ecx,%ecx
mov    %r10d,%eax
xor    %r11d,%r11d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movl   $0x1,(%rbx,%rcx,4)
mov    (%r14,%rcx,4),%esi
cmp    %eax,%esi
mov    %r11d,%edx
cmovg  %ecx,%edx
cmovg  %esi,%eax
cmp    %r10d,%esi
cmovl  %esi,%r10d
movl   $0x1,0x4(%rbx,%rcx,4)
mov    0x4(%r14,%rcx,4),%esi
lea    0x1(%rcx),%r11d
cmp    %eax,%esi
cmovle %edx,%r11d
cmovg  %esi,%eax
cmp    %r10d,%esi
cmovl  %esi,%r10d
add    $0x2,%rcx
cmp    %r9,%rcx
jne    1190 <iond_calc_smx_sizes+0x80>
test   $0x1,%r8b
je     11f8 <iond_calc_smx_sizes+0xe8>
movl   $0x1,(%rbx,%rcx,4)
mov    (%r14,%rcx,4),%esi
cmp    %eax,%esi
cmovg  %ecx,%r11d
cmovg  %esi,%eax
cmp    %r10d,%esi
cmovl  %esi,%r10d
mov    %r10d,0x14(%rsp)
mov    %r11d,%r11d
mov    %eax,%r10d
lea    (%rbx,%r8,4),%rax
lea    (%r14,%r8,4),%rcx
lea    -0x1(%r8),%rdx
mov    %rdx,0x40(%rsp)
cmp    %rbx,%rcx
seta   %cl
cmp    %r14,%rax
seta   %al
and    %cl,%al
mov    %al,0xf(%rsp)
mov    %r8d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x50(%rsp)
mov    %r8d,%r9d
and    $0x3,%r9d
mov    %r8d,%r12d
and    $0xfffffffc,%r12d
mov    %r8,0x18(%rsp)
lea    0x0(,%r8,4),%rax
mov    %rax,0x60(%rsp)
mov    %rax,%r13
and    $0xffffffffffffffe0,%r13
mov    $0x1,%r15d
mov    %edi,0x2c(%rsp)
mov    %r10d,0x10(%rsp)
mov    %r11,0x58(%rsp)
mov    %r9,0x38(%rsp)
mov    %r12,0x30(%rsp)
mov    %r13,0x48(%rsp)
nopl   0x0(%rax,%rax,1)
test   %edi,%edi
jle    15a0 <iond_calc_smx_sizes+0x490>
mov    %rbp,0x20(%rsp)
xor    %r13d,%r13d
xor    %r12d,%r12d
jmp    12b1 <iond_calc_smx_sizes+0x1a1>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %edx,(%rcx)
add    $0x1,%r12
add    $0x4,%r13
cmp    %r13,0x60(%rsp)
je     1330 <iond_calc_smx_sizes+0x220>
mov    (%r14,%r13,1),%eax
cltd
idivl  0x14(%rsp)
mov    %eax,%ebp
cmp    $0x4,%eax
jl     12c6 <iond_calc_smx_sizes+0x1b6>
mov    $0x4,%ebp
mov    $0x2,%edi
mov    %ebp,%esi
call   1030 <pow@plt>
imul   %r15d,%eax
cmp    $0x21,%eax
jl     12f0 <iond_calc_smx_sizes+0x1e0>
lea    (%rbx,%r12,4),%rcx
mov    $0x20,%eax
jmp    130e <iond_calc_smx_sizes+0x1fe>
cs nopw 0x0(%rax,%rax,1)
mov    $0x2,%edi
mov    %ebp,%esi
call   1030 <pow@plt>
imul   %r15d,%eax
lea    (%rbx,%r13,1),%rcx
mov    $0x4,%edx
cmp    $0x5,%eax
jl     1310 <iond_calc_smx_sizes+0x200>
mov    %eax,%edx
mov    %edx,(%rcx)
mov    (%r14,%r13,1),%eax
cmp    %eax,%edx
pcmpeqd %xmm9,%xmm9
jl     12a0 <iond_calc_smx_sizes+0x190>
mov    %eax,%edx
jmp    12a0 <iond_calc_smx_sizes+0x190>
cs nopw 0x0(%rax,%rax,1)
mov    0x2c(%rsp),%edi
test   %edi,%edi
mov    0x58(%rsp),%r11
jle    1370 <iond_calc_smx_sizes+0x260>
cmp    $0x8,%edi
setb   %al
or     0xf(%rsp),%al
je     1382 <iond_calc_smx_sizes+0x272>
xor    %ecx,%ecx
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%r10d
mov    0x38(%rsp),%r9
mov    0x20(%rsp),%rbp
mov    0x30(%rsp),%r12
jmp    14eb <iond_calc_smx_sizes+0x3db>
nopl   0x0(%rax)
mov    0x10(%rsp),%r10d
mov    %r10d,%eax
mov    0x20(%rsp),%rbp
jmp    15a3 <iond_calc_smx_sizes+0x493>
movd   0x20(%rsp),%xmm1
pxor   %xmm0,%xmm0
xor    %eax,%eax
mov    0x18(%rsp),%r8
mov    0x30(%rsp),%r12
mov    0x48(%rsp),%r13
jmp    13d7 <iond_calc_smx_sizes+0x2c7>
nop
movdqa 0xc58(%rip),%xmm4
pcmpeqd %xmm4,%xmm3
psubd  %xmm3,%xmm1
pcmpeqd %xmm4,%xmm6
psubd  %xmm6,%xmm0
paddd  %xmm2,%xmm1
psubd  %xmm9,%xmm1
paddd  %xmm5,%xmm0
psubd  %xmm9,%xmm0
add    $0x20,%rax
cmp    %rax,%r13
je     14ba <iond_calc_smx_sizes+0x3aa>
movdqu (%rbx,%rax,1),%xmm3
movdqu (%r14,%rax,1),%xmm5
movdqu 0x10(%r14,%rax,1),%xmm8
movdqa %xmm5,%xmm2
pcmpgtd %xmm3,%xmm2
movdqa %xmm2,%xmm6
pxor   %xmm9,%xmm6
movd   %xmm6,%ecx
test   $0x1,%cl
je     1408 <iond_calc_smx_sizes+0x2f8>
movd   %xmm5,(%rbx,%rax,1)
pextrw $0x2,%xmm6,%ecx
test   $0x1,%cl
je     141d <iond_calc_smx_sizes+0x30d>
pshufd $0x55,%xmm5,%xmm7
movd   %xmm7,0x4(%rbx,%rax,1)
pextrw $0x4,%xmm6,%ecx
test   $0x1,%cl
je     1432 <iond_calc_smx_sizes+0x322>
pshufd $0xee,%xmm5,%xmm7
movd   %xmm7,0x8(%rbx,%rax,1)
pextrw $0x6,%xmm6,%ecx
test   $0x1,%cl
je     1447 <iond_calc_smx_sizes+0x337>
pshufd $0xff,%xmm5,%xmm5
movd   %xmm5,0xc(%rbx,%rax,1)
movdqu 0x10(%rbx,%rax,1),%xmm6
movdqa %xmm8,%xmm5
pcmpgtd %xmm6,%xmm5
movdqa %xmm5,%xmm7
pxor   %xmm9,%xmm7
movd   %xmm7,%ecx
test   $0x1,%cl
je     146f <iond_calc_smx_sizes+0x35f>
movd   %xmm8,0x10(%rbx,%rax,1)
pextrw $0x2,%xmm7,%ecx
test   $0x1,%cl
je     1485 <iond_calc_smx_sizes+0x375>
pshufd $0x55,%xmm8,%xmm4
movd   %xmm4,0x14(%rbx,%rax,1)
pextrw $0x4,%xmm7,%ecx
test   $0x1,%cl
je     149b <iond_calc_smx_sizes+0x38b>
pshufd $0xee,%xmm8,%xmm4
movd   %xmm4,0x18(%rbx,%rax,1)
pextrw $0x6,%xmm7,%ecx
test   $0x1,%cl
je     13a0 <iond_calc_smx_sizes+0x290>
pshufd $0xff,%xmm8,%xmm4
movd   %xmm4,0x1c(%rbx,%rax,1)
jmp    13a0 <iond_calc_smx_sizes+0x290>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ebp
mov    0x50(%rsp),%rax
mov    %rax,%rcx
cmp    %r8,%rax
mov    0x10(%rsp),%r10d
mov    0x38(%rsp),%r9
je     1530 <iond_calc_smx_sizes+0x420>
test   $0x1,%r8b
jne    14fd <iond_calc_smx_sizes+0x3ed>
mov    %rcx,%rax
cmp    %rcx,0x40(%rsp)
jne    1559 <iond_calc_smx_sizes+0x449>
jmp    1530 <iond_calc_smx_sizes+0x420>
mov    (%rbx,%rcx,4),%edx
xor    %eax,%eax
cmp    $0x20,%edx
sete   %al
add    %eax,%ebp
mov    (%r14,%rcx,4),%eax
cmp    %eax,%edx
jl     1518 <iond_calc_smx_sizes+0x408>
mov    %eax,(%rbx,%rcx,4)
add    $0x1,%ebp
mov    %rcx,%rax
or     $0x1,%rax
cmp    %rcx,0x40(%rsp)
jne    1559 <iond_calc_smx_sizes+0x449>
cs nopw 0x0(%rax,%rax,1)
test   %edi,%edi
jle    15a0 <iond_calc_smx_sizes+0x490>
cmpq   $0x3,0x40(%rsp)
jae    15be <iond_calc_smx_sizes+0x4ae>
xor    %ecx,%ecx
mov    %r10d,%eax
test   %r9,%r9
jne    161a <iond_calc_smx_sizes+0x50a>
jmp    15a3 <iond_calc_smx_sizes+0x493>
add    $0x2,%rax
cmp    %rax,%r8
je     1530 <iond_calc_smx_sizes+0x420>
mov    (%rbx,%rax,4),%esi
xor    %ecx,%ecx
cmp    $0x20,%esi
sete   %cl
add    %ebp,%ecx
mov    (%r14,%rax,4),%edx
cmp    %edx,%esi
jl     1574 <iond_calc_smx_sizes+0x464>
mov    %edx,(%rbx,%rax,4)
add    $0x1,%ecx
mov    0x4(%rbx,%rax,4),%edx
xor    %ebp,%ebp
cmp    $0x20,%edx
sete   %bpl
add    %ecx,%ebp
mov    0x4(%r14,%rax,4),%ecx
cmp    %ecx,%edx
jl     1550 <iond_calc_smx_sizes+0x440>
mov    %ecx,0x4(%rbx,%rax,4)
add    $0x1,%ebp
jmp    1550 <iond_calc_smx_sizes+0x440>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r10d,%eax
cmp    $0x10001,%eax
jae    1648 <iond_calc_smx_sizes+0x538>
add    %r15d,%r15d
cmp    %edi,%ebp
jl     1280 <iond_calc_smx_sizes+0x170>
jmp    113b <iond_calc_smx_sizes+0x2b>
xor    %edx,%edx
mov    %r10d,%eax
jmp    15d9 <iond_calc_smx_sizes+0x4c9>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdx
cmp    %r12,%rdx
je     1611 <iond_calc_smx_sizes+0x501>
mov    %rdx,%rcx
cmp    %rdx,%r11
je     15e5 <iond_calc_smx_sizes+0x4d5>
imul   (%rbx,%rcx,4),%eax
lea    0x1(%rcx),%rdx
cmp    %r11,%rdx
je     15f3 <iond_calc_smx_sizes+0x4e3>
imul   0x4(%rbx,%rcx,4),%eax
add    $0x1,%rdx
cmp    %r11,%rdx
je     1601 <iond_calc_smx_sizes+0x4f1>
imul   0x8(%rbx,%rcx,4),%eax
add    $0x1,%rdx
cmp    %r11,%rdx
je     15d0 <iond_calc_smx_sizes+0x4c0>
imul   0xc(%rbx,%rcx,4),%eax
jmp    15d0 <iond_calc_smx_sizes+0x4c0>
add    $0x4,%rcx
test   %r9,%r9
je     15a3 <iond_calc_smx_sizes+0x493>
lea    (%rbx,%rcx,4),%rdx
mov    %r11,%rsi
sub    %rcx,%rsi
xor    %ecx,%ecx
jmp    163d <iond_calc_smx_sizes+0x52d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %rcx,%r9
je     15a3 <iond_calc_smx_sizes+0x493>
cmp    %rcx,%rsi
je     1630 <iond_calc_smx_sizes+0x520>
imul   (%rdx,%rcx,4),%eax
jmp    1630 <iond_calc_smx_sizes+0x520>
test   %edi,%edi
jle    113b <iond_calc_smx_sizes+0x2b>
mov    %r15d,%r12d
shr    $0x1f,%r12d
add    %r15d,%r12d
sar    %r12d
shlq   $0x2,0x18(%rsp)
xor    %ebp,%ebp
xor    %r13d,%r13d
jmp    1685 <iond_calc_smx_sizes+0x575>
nopw   0x0(%rax,%rax,1)
mov    %edx,(%rcx)
add    $0x1,%r13
add    $0x4,%rbp
cmp    %rbp,0x18(%rsp)
je     113b <iond_calc_smx_sizes+0x2b>
mov    (%r14,%rbp,1),%eax
cltd
idivl  0x14(%rsp)
mov    %eax,%r15d
cmp    $0x4,%eax
jl     169c <iond_calc_smx_sizes+0x58c>
mov    $0x4,%r15d
mov    $0x2,%edi
mov    %r15d,%esi
call   1030 <pow@plt>
imul   %r12d,%eax
cmp    $0x21,%eax
jl     16c0 <iond_calc_smx_sizes+0x5b0>
lea    (%rbx,%r13,4),%rcx
mov    $0x20,%eax
jmp    16df <iond_calc_smx_sizes+0x5cf>
nopl   (%rax)
mov    $0x2,%edi
mov    %r15d,%esi
call   1030 <pow@plt>
imul   %r12d,%eax
lea    (%rbx,%rbp,1),%rcx
mov    $0x4,%edx
cmp    $0x5,%eax
jl     16e1 <iond_calc_smx_sizes+0x5d1>
mov    %eax,%edx
mov    %edx,(%rcx)
mov    (%r14,%rbp,1),%eax
cmp    %eax,%edx
jl     1670 <iond_calc_smx_sizes+0x560>
mov    %eax,%edx
jmp    1670 <iond_calc_smx_sizes+0x560>

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

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