#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 /*<<< orphan*/ free(size_t *);
scalar_t__ malloc(int);
int calculate_glszm(int *image, char *mask, int *size, int *bb, int *strides,
                    int *angles, int Na, int Nd, int *tempData, int Ng, int Ns,
                    int Nvox) {
  size_t Ni;
  size_t i, j, k;
  size_t *cur_idx = (size_t *)malloc(sizeof *cur_idx * Nd);
  size_t *regionStack;
  size_t stackTop = 0;
  size_t *processedStack = NULL;
  size_t processed_idx = 0;
  size_t a, d;
  int gl, region;
  int maxSize = 0;
  size_t temp_idx = 0;
  size_t temp_idx_max = Ns * 2;
  regionStack = (size_t *)malloc(sizeof *regionStack * Ns);
  if (Nvox > 1)
    processedStack = (size_t *)malloc(sizeof *processedStack * Ns);
  Ni = size[0];
  i = bb[0] * strides[0];
  for (d = 1; d < Nd; d++) {
    i += bb[d] * strides[d];
    Ni *= size[d];
  }
  for (; i < Ni; i++) {
    for (d = Nd - 1; d > 0; d--) {
      cur_idx[d] = (i % strides[d - 1]) / strides[d];
      if (cur_idx[d] > bb[Nd + d])
        i += (size[d] - cur_idx[d] + bb[d]) * strides[d];
      else if (cur_idx[d] < bb[d])
        i += (bb[d] - cur_idx[d]) * strides[d];
    }
    if (i / strides[0] > bb[Nd])
      break;
    if (mask[i]) {
      gl = image[i];
      region = 0;
      if (processedStack) {
        if (processed_idx >= Ns) {
          free(cur_idx);
          free(regionStack);
          return -1;
        }
        processedStack[processed_idx++] = i;
      }
      regionStack[stackTop++] = i;
      mask[i] = 0;
      while (stackTop > 0) {
        k = regionStack[--stackTop];
        region++;
        cur_idx[0] = k / strides[0];
        for (d = 1; d < Nd; d++)
          cur_idx[d] = (k % strides[d - 1]) / strides[d];
        for (a = 0; a < Na; a++) {
          j = k;
          for (d = 0; d < Nd; d++) {
            if (cur_idx[d] + angles[a * Nd + d] < bb[d] ||
                cur_idx[d] + angles[a * Nd + d] > bb[Nd + d]) {
              j = k;
              break;
            }
            j += angles[a * Nd + d] * strides[d];
          }
          if (j != k && mask[j] && (image[j] == gl)) {
            if (processedStack) {
              if (processed_idx >= Ns) {
                free(cur_idx);
                free(regionStack);
                return -1;
              }
              processedStack[processed_idx++] = j;
            }
            regionStack[stackTop++] = j;
            mask[j] = 0;
          }
        }
      }
      if (temp_idx >= temp_idx_max) {
        free(cur_idx);
        free(regionStack);
        return -1;
      }
      if (region > maxSize)
        maxSize = region;
      tempData[(temp_idx * 2)] = gl;
      tempData[((temp_idx * 2) + 1)] = region;
      temp_idx++;
    }
  }
  free(cur_idx);
  free(regionStack);
  if (processedStack) {
    while (processed_idx > 0)
      mask[processedStack[--processed_idx]] = 1;
    free(processedStack);
  }
  if (temp_idx >= temp_idx_max)
    return -1;
  tempData[(temp_idx * 2)] = -1;
  return maxSize;
}


x86 assembly (clang, -O0):
<calculate_glszm>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movslq 0x18(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x60(%rbp)
movq   $0x0,-0x70(%rbp)
movq   $0x0,-0x78(%rbp)
movq   $0x0,-0x80(%rbp)
movl   $0x0,-0x9c(%rbp)
movq   $0x0,-0xa8(%rbp)
mov    0x30(%rbp),%eax
shl    $0x1,%eax
cltq
mov    %rax,-0xb0(%rbp)
movslq 0x30(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x68(%rbp)
cmpl   $0x1,0x38(%rbp)
jle    11d5 <calculate_glszm+0xb5>
movslq 0x30(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x78(%rbp)
mov    -0x20(%rbp),%rax
movslq (%rax),%rax
mov    %rax,-0x40(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    -0x30(%rbp),%rcx
imul   (%rcx),%eax
cltq
mov    %rax,-0x48(%rbp)
movq   $0x1,-0x90(%rbp)
mov    -0x90(%rbp),%rax
movslq 0x18(%rbp),%rcx
cmp    %rcx,%rax
jae    1268 <calculate_glszm+0x148>
mov    -0x28(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x30(%rbp),%rcx
mov    -0x90(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
cltq
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x90(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
imul   -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x90(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x90(%rbp)
jmp    11fe <calculate_glszm+0xde>
jmp    126d <calculate_glszm+0x14d>
mov    -0x48(%rbp),%rax
cmp    -0x40(%rbp),%rax
jae    182b <calculate_glszm+0x70b>
mov    0x18(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %rax,-0x90(%rbp)
cmpq   $0x0,-0x90(%rbp)
jbe    13d9 <calculate_glszm+0x2b9>
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x90(%rbp),%rdx
sub    $0x1,%rdx
movslq (%rcx,%rdx,4),%rcx
xor    %edx,%edx
div    %rcx
mov    %rdx,%rax
mov    -0x30(%rbp),%rcx
mov    -0x90(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
xor    %edx,%edx
div    %rcx
mov    %rax,%rdx
mov    -0x60(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
movslq 0x18(%rbp),%rdx
add    -0x90(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
cmp    %rcx,%rax
jbe    1358 <calculate_glszm+0x238>
mov    -0x20(%rbp),%rax
mov    -0x90(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
mov    -0x60(%rbp),%rcx
mov    -0x90(%rbp),%rdx
sub    (%rcx,%rdx,8),%rax
mov    -0x28(%rbp),%rcx
mov    -0x90(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%rcx
mov    -0x90(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
imul   %rcx,%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
jmp    13bd <calculate_glszm+0x29d>
mov    -0x60(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
mov    -0x90(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
cmp    %rcx,%rax
jae    13b8 <calculate_glszm+0x298>
mov    -0x28(%rbp),%rax
mov    -0x90(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
mov    -0x60(%rbp),%rcx
mov    -0x90(%rbp),%rdx
sub    (%rcx,%rdx,8),%rax
mov    -0x30(%rbp),%rcx
mov    -0x90(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
imul   %rcx,%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
jmp    13bd <calculate_glszm+0x29d>
jmp    13c2 <calculate_glszm+0x2a2>
mov    -0x90(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x90(%rbp)
jmp    128a <calculate_glszm+0x16a>
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
xor    %edx,%edx
div    %rcx
mov    -0x28(%rbp),%rcx
movslq 0x18(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
cmp    %rcx,%rax
jbe    1403 <calculate_glszm+0x2e3>
jmp    182b <calculate_glszm+0x70b>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
je     1815 <calculate_glszm+0x6f5>
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x94(%rbp)
movl   $0x0,-0x98(%rbp)
cmpq   $0x0,-0x78(%rbp)
je     1485 <calculate_glszm+0x365>
mov    -0x80(%rbp),%rax
movslq 0x30(%rbp),%rcx
cmp    %rcx,%rax
jb     146a <calculate_glszm+0x34a>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    18c5 <calculate_glszm+0x7a5>
mov    -0x48(%rbp),%rdx
mov    -0x78(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x80(%rbp)
mov    %rdx,(%rax,%rcx,8)
mov    -0x48(%rbp),%rdx
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x70(%rbp)
mov    %rdx,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
cmpq   $0x0,-0x70(%rbp)
jbe    1782 <calculate_glszm+0x662>
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    %rcx,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x70(%rbp)
mov    -0x8(%rax,%rcx,8),%rax
mov    %rax,-0x58(%rbp)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
xor    %edx,%edx
div    %rcx
mov    %rax,%rcx
mov    -0x60(%rbp),%rax
mov    %rcx,(%rax)
movq   $0x1,-0x90(%rbp)
mov    -0x90(%rbp),%rax
movslq 0x18(%rbp),%rcx
cmp    %rcx,%rax
jae    1577 <calculate_glszm+0x457>
mov    -0x58(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x90(%rbp),%rdx
sub    $0x1,%rdx
movslq (%rcx,%rdx,4),%rcx
xor    %edx,%edx
div    %rcx
mov    %rdx,%rax
mov    -0x30(%rbp),%rcx
mov    -0x90(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
xor    %edx,%edx
div    %rcx
mov    %rax,%rdx
mov    -0x60(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x90(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x90(%rbp)
jmp    1507 <calculate_glszm+0x3e7>
movq   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%rax
movslq 0x10(%rbp),%rcx
cmp    %rcx,%rax
jae    177d <calculate_glszm+0x65d>
mov    -0x58(%rbp),%rax
mov    %rax,-0x50(%rbp)
movq   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%rax
movslq 0x18(%rbp),%rcx
cmp    %rcx,%rax
jae    16ab <calculate_glszm+0x58b>
mov    -0x60(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%rcx
mov    -0x88(%rbp),%rdx
movslq 0x18(%rbp),%rsi
imul   %rsi,%rdx
add    -0x90(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
add    %rcx,%rax
mov    -0x28(%rbp),%rcx
mov    -0x90(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
cmp    %rcx,%rax
jb     1651 <calculate_glszm+0x531>
mov    -0x60(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%rcx
mov    -0x88(%rbp),%rdx
movslq 0x18(%rbp),%rsi
imul   %rsi,%rdx
add    -0x90(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
add    %rcx,%rax
mov    -0x28(%rbp),%rcx
movslq 0x18(%rbp),%rdx
add    -0x90(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
cmp    %rcx,%rax
jbe    165e <calculate_glszm+0x53e>
mov    -0x58(%rbp),%rax
mov    %rax,-0x50(%rbp)
jmp    16ab <calculate_glszm+0x58b>
mov    -0x38(%rbp),%rax
mov    -0x88(%rbp),%rcx
movslq 0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x90(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x30(%rbp),%rcx
mov    -0x90(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
cltq
add    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x90(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x90(%rbp)
jmp    15a9 <calculate_glszm+0x489>
mov    -0x50(%rbp),%rax
cmp    -0x58(%rbp),%rax
je     1761 <calculate_glszm+0x641>
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1761 <calculate_glszm+0x641>
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x94(%rbp),%eax
jne    1761 <calculate_glszm+0x641>
cmpq   $0x0,-0x78(%rbp)
je     173a <calculate_glszm+0x61a>
mov    -0x80(%rbp),%rax
movslq 0x30(%rbp),%rcx
cmp    %rcx,%rax
jb     171f <calculate_glszm+0x5ff>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    18c5 <calculate_glszm+0x7a5>
mov    -0x50(%rbp),%rdx
mov    -0x78(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x80(%rbp)
mov    %rdx,(%rax,%rcx,8)
mov    -0x50(%rbp),%rdx
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x70(%rbp)
mov    %rdx,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    1766 <calculate_glszm+0x646>
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
jmp    1582 <calculate_glszm+0x462>
jmp    14ac <calculate_glszm+0x38c>
mov    -0xa8(%rbp),%rax
cmp    -0xb0(%rbp),%rax
jb     17b4 <calculate_glszm+0x694>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    18c5 <calculate_glszm+0x7a5>
mov    -0x98(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jle    17d2 <calculate_glszm+0x6b2>
mov    -0x98(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x94(%rbp),%edx
mov    0x20(%rbp),%rax
mov    -0xa8(%rbp),%rcx
shl    $0x1,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x98(%rbp),%edx
mov    0x20(%rbp),%rax
mov    -0xa8(%rbp),%rcx
shl    $0x1,%rcx
mov    %edx,0x4(%rax,%rcx,4)
mov    -0xa8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xa8(%rbp)
jmp    181a <calculate_glszm+0x6fa>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    126d <calculate_glszm+0x14d>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
cmpq   $0x0,-0x78(%rbp)
je     1886 <calculate_glszm+0x766>
jmp    184d <calculate_glszm+0x72d>
cmpq   $0x0,-0x80(%rbp)
jbe    187d <calculate_glszm+0x75d>
mov    -0x18(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    -0x80(%rbp),%rdx
mov    %rdx,%rsi
add    $0xffffffffffffffff,%rsi
mov    %rsi,-0x80(%rbp)
mov    -0x8(%rcx,%rdx,8),%rcx
movb   $0x1,(%rax,%rcx,1)
jmp    184d <calculate_glszm+0x72d>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa8(%rbp),%rax
cmp    -0xb0(%rbp),%rax
jb     18a6 <calculate_glszm+0x786>
movl   $0xffffffff,-0x4(%rbp)
jmp    18c5 <calculate_glszm+0x7a5>
mov    0x20(%rbp),%rax
mov    -0xa8(%rbp),%rcx
shl    $0x1,%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x9c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calculate_glszm>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
mov    %r9,0x88(%rsp)
mov    %r8,%r12
mov    %rcx,%r13
mov    %rdx,%rbx
mov    %rsi,%r14
mov    %rdi,0x78(%rsp)
movslq 0x120(%rsp),%rbp
mov    0x108(%rsp),%eax
lea    0x0(,%rax,8),%edi
call   1040 <malloc@plt>
mov    %rax,%r15
mov    %rbp,0x48(%rsp)
lea    0x0(,%rbp,8),%ebp
mov    %ebp,%edi
call   1040 <malloc@plt>
mov    %rax,0x10(%rsp)
cmpl   $0x2,0x128(%rsp)
02
jl     1196 <calculate_glszm+0x76>
mov    %ebp,%edi
call   1040 <malloc@plt>
mov    %rax,%rbp
jmp    1198 <calculate_glszm+0x78>
xor    %ebp,%ebp
mov    0x108(%rsp),%edx
mov    0x48(%rsp),%rax
lea    (%rax,%rax,1),%r11d
movslq %edx,%r10
mov    %rbx,0x28(%rsp)
movslq (%rbx),%rbx
movslq 0x0(%r13),%rcx
movslq (%r12),%rdi
imul   %rcx,%rdi
cmp    $0x2,%edx
mov    %rbp,0x20(%rsp)
jb     126c <calculate_glszm+0x14c>
lea    -0x1(%r10),%r8
cmp    $0x2,%edx
jne    11dd <calculate_glszm+0xbd>
mov    $0x1,%edx
jmp    1244 <calculate_glszm+0x124>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
neg    %rcx
mov    $0x1,%edx
mov    0x28(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq 0x0(%r13,%rdx,4),%rsi
movslq (%r12,%rdx,4),%rbp
imul   %rsi,%rbp
add    %rdi,%rbp
movslq (%r9,%rdx,4),%rax
imul   %rbx,%rax
movslq 0x4(%r13,%rdx,4),%rsi
movslq 0x4(%r12,%rdx,4),%rdi
imul   %rsi,%rdi
add    %rbp,%rdi
movslq 0x4(%r9,%rdx,4),%rbx
imul   %rax,%rbx
lea    (%rcx,%rdx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rdx
cmp    $0x1,%rsi
jne    1200 <calculate_glszm+0xe0>
test   $0x1,%r8b
mov    0x20(%rsp),%rbp
je     126c <calculate_glszm+0x14c>
movslq 0x0(%r13,%rdx,4),%rcx
movslq (%r12,%rdx,4),%rsi
imul   %rcx,%rsi
add    %rsi,%rdi
mov    0x28(%rsp),%rax
movslq (%rax,%rdx,4),%rcx
imul   %rcx,%rbx
movslq %r11d,%rax
mov    %rax,0x68(%rsp)
cmp    %rbx,%rdi
jae    17d3 <calculate_glszm+0x6b3>
mov    %rdi,%rdx
mov    0x100(%rsp),%ecx
lea    -0x1(%r10),%rsi
cmp    $0x2,%r10
mov    $0x1,%edi
mov    $0x1,%r8d
cmovae %r10,%r8
cmp    $0x2,%ecx
mov    $0x1,%eax
cmovae %ecx,%eax
cltq
mov    %rax,0xc0(%rsp)
mov    %r10,%rcx
lea    -0x4(%r13,%r10,4),%r10
mov    0x28(%rsp),%rax
lea    -0x4(%rax,%rcx,4),%rax
mov    %rax,0x90(%rsp)
lea    -0x1(%rcx,%rcx,1),%rax
lea    0x0(%r13,%rax,4),%rax
mov    %rax,0xa8(%rsp)
lea    (%r15,%rcx,8),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0xa0(%rsp)
sub    %rcx,%rdi
mov    %rdi,0xb0(%rsp)
lea    (%r12,%rcx,4),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x98(%rsp)
mov    %rsi,%rax
and    $0xfffffffffffffffe,%rax
neg    %rax
mov    %rax,0xb8(%rsp)
mov    %rcx,0x80(%rsp)
lea    0x0(,%rcx,4),%rax
mov    %rax,0x28(%rsp)
xor    %eax,%eax
mov    %rax,0x38(%rsp)
movl   $0x0,0xc(%rsp)
xor    %eax,%eax
mov    %rax,0x18(%rsp)
mov    %rbx,0x60(%rsp)
mov    %rsi,0x50(%rsp)
jmp    1377 <calculate_glszm+0x257>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x60(%rsp),%rax
mov    0x50(%rsp),%rsi
add    $0x1,%rdx
cmp    %rax,%rdx
jae    17e9 <calculate_glszm+0x6c9>
test   %esi,%esi
je     1450 <calculate_glszm+0x330>
mov    (%r12,%rsi,4),%r11d
xor    %esi,%esi
jmp    13c2 <calculate_glszm+0x2a2>
nopw   0x0(%rax,%rax,1)
mov    0x90(%rsp),%rdx
movslq (%rdx,%rsi,4),%rdx
sub    %rax,%rdx
movslq (%r10,%rsi,4),%rax
add    %rdx,%rax
imul   %rcx,%rax
mov    %rbx,%rdx
add    %rax,%rdx
add    $0xffffffffffffffff,%rsi
cmp    %rsi,0xb0(%rsp)
je     1450 <calculate_glszm+0x330>
mov    %r11d,%edi
mov    0x98(%rsp),%rax
mov    (%rax,%rsi,4),%r11d
movslq %r11d,%rcx
mov    %rdx,%rax
or     %rcx,%rax
mov    %rdx,%rbx
shr    $0x20,%rax
je     13f0 <calculate_glszm+0x2d0>
mov    %rdx,%rax
xor    %edx,%edx
div    %rcx
mov    %rdx,%rax
jmp    13f9 <calculate_glszm+0x2d9>
mov    %edx,%eax
xor    %edx,%edx
div    %r11d
mov    %edx,%eax
movslq %edi,%rcx
mov    %rax,%rdx
or     %rcx,%rdx
shr    $0x20,%rdx
je     1410 <calculate_glszm+0x2f0>
xor    %edx,%edx
div    %rcx
jmp    1414 <calculate_glszm+0x2f4>
nop
xor    %edx,%edx
div    %edi
mov    0xa0(%rsp),%rdx
mov    %rax,(%rdx,%rsi,8)
mov    0xa8(%rsp),%rdx
movslq (%rdx,%rsi,4),%rdx
cmp    %rdx,%rax
ja     1390 <calculate_glszm+0x270>
movslq (%r10,%rsi,4),%rdx
cmp    %rdx,%rax
jae    1448 <calculate_glszm+0x328>
sub    %rax,%rdx
imul   %rcx,%rdx
add    %rdx,%rbx
mov    %rbx,%rdx
jmp    13b0 <calculate_glszm+0x290>
movslq (%r12),%rcx
mov    %rdx,%rax
or     %rcx,%rax
shr    $0x20,%rax
mov    %rdx,0x70(%rsp)
je     1470 <calculate_glszm+0x350>
mov    %rdx,%rax
xor    %edx,%edx
div    %rcx
jmp    1476 <calculate_glszm+0x356>
nop
mov    %edx,%eax
xor    %edx,%edx
div    %ecx
mov    0x108(%rsp),%r11d
mov    0x80(%rsp),%rcx
movslq 0x0(%r13,%rcx,4),%rcx
cmp    %rcx,%rax
ja     17e9 <calculate_glszm+0x6c9>
mov    0x70(%rsp),%rdx
cmpb   $0x0,(%r14,%rdx,1)
je     1360 <calculate_glszm+0x240>
mov    0x78(%rsp),%rax
mov    (%rax,%rdx,4),%eax
mov    %eax,0x34(%rsp)
test   %rbp,%rbp
je     14d3 <calculate_glszm+0x3b3>
mov    0x18(%rsp),%rax
cmp    0x48(%rsp),%rax
jae    1899 <calculate_glszm+0x779>
mov    %rdx,0x0(%rbp,%rax,8)
add    $0x1,%rax
mov    %rax,0x18(%rsp)
mov    0x10(%rsp),%rax
mov    %rdx,(%rax)
movb   $0x0,(%r14,%rdx,1)
mov    $0x1,%ecx
xor    %edi,%edi
jmp    1515 <calculate_glszm+0x3f5>
nopl   0x0(%rax)
mov    %rdi,%r14
mov    0x108(%rsp),%r11d
mov    0x5c(%rsp),%edi
add    $0x1,%edi
mov    0x40(%rsp),%rcx
test   %rcx,%rcx
mov    0x70(%rsp),%rdx
je     1790 <calculate_glszm+0x670>
mov    %edi,0x5c(%rsp)
mov    %r14,%rdi
mov    0x10(%rsp),%rax
mov    %rcx,0x40(%rsp)
mov    -0x8(%rax,%rcx,8),%r9
mov    (%r12),%r14d
movslq %r14d,%rcx
mov    %r9,%rax
or     %rcx,%rax
shr    $0x20,%rax
je     1550 <calculate_glszm+0x430>
mov    %r9,%rax
xor    %edx,%edx
div    %rcx
jmp    1558 <calculate_glszm+0x438>
nopl   0x0(%rax,%rax,1)
mov    %r9d,%eax
xor    %edx,%edx
div    %r14d
mov    %rax,(%r15)
cmp    $0x2,%r11d
jb     1694 <calculate_glszm+0x574>
mov    $0x1,%r11d
jne    15c3 <calculate_glszm+0x4a3>
testb  $0x1,0x50(%rsp)
je     1694 <calculate_glszm+0x574>
movslq %r14d,%rcx
mov    %r9,%rax
or     %rcx,%rax
shr    $0x20,%rax
je     166b <calculate_glszm+0x54b>
mov    %r9,%rax
xor    %edx,%edx
div    %rcx
mov    %rdx,%rax
jmp    1675 <calculate_glszm+0x555>
nopl   0x0(%rax,%rax,1)
xor    %edx,%edx
div    %rcx
mov    %rax,0x8(%r15,%r11,8)
mov    0xb8(%rsp),%rax
add    %r11,%rax
add    $0x2,%rax
add    $0x2,%r11
cmp    $0x1,%rax
je     156d <calculate_glszm+0x44d>
movslq %r14d,%rcx
mov    %r9,%rax
or     %rcx,%rax
shr    $0x20,%rax
je     15e0 <calculate_glszm+0x4c0>
mov    %r9,%rax
xor    %edx,%edx
div    %rcx
mov    %rdx,%rax
jmp    15ea <calculate_glszm+0x4ca>
nop
mov    %r9d,%eax
xor    %edx,%edx
div    %r14d
mov    %edx,%eax
movslq (%r12,%r11,4),%rsi
mov    %rax,%rcx
or     %rsi,%rcx
shr    $0x20,%rcx
je     1610 <calculate_glszm+0x4f0>
xor    %edx,%edx
div    %rsi
jmp    1614 <calculate_glszm+0x4f4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %edx,%edx
div    %esi
mov    %rax,(%r15,%r11,8)
mov    %rsi,%rax
or     %r9,%rax
shr    $0x20,%rax
je     1640 <calculate_glszm+0x520>
mov    %r9,%rax
xor    %edx,%edx
div    %rsi
mov    %rdx,%rax
jmp    1649 <calculate_glszm+0x529>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r9d,%eax
xor    %edx,%edx
div    %esi
mov    %edx,%eax
mov    0x4(%r12,%r11,4),%r14d
movslq %r14d,%rcx
mov    %rax,%rdx
or     %rcx,%rdx
shr    $0x20,%rdx
jne    15a0 <calculate_glszm+0x480>
xor    %edx,%edx
div    %r14d
jmp    15a5 <calculate_glszm+0x485>
mov    %r9d,%eax
xor    %edx,%edx
div    %r14d
mov    %edx,%eax
movslq (%r12,%r11,4),%rsi
mov    %rax,%rcx
or     %rsi,%rcx
shr    $0x20,%rcx
je     168c <calculate_glszm+0x56c>
xor    %edx,%edx
div    %rsi
jmp    1690 <calculate_glszm+0x570>
xor    %edx,%edx
div    %esi
mov    %rax,(%r15,%r11,8)
addq   $0xffffffffffffffff,0x40(%rsp)
cmpl   $0x0,0x100(%rsp)
je     14f0 <calculate_glszm+0x3d0>
mov    0x88(%rsp),%rax
xor    %edx,%edx
mov    %rdi,%r14
mov    0x108(%rsp),%r11d
jmp    1707 <calculate_glszm+0x5e7>
mov    0x20(%rsp),%rcx
mov    %rsi,(%rcx,%rdi,8)
add    $0x1,%rdi
mov    %rdi,0x18(%rsp)
mov    0x10(%rsp),%rcx
mov    0x40(%rsp),%rdi
mov    %rsi,(%rcx,%rdi,8)
add    $0x1,%rdi
mov    %rdi,0x40(%rsp)
movb   $0x0,(%r14,%rsi,1)
nopl   (%rax)
add    $0x1,%rdx
add    0x28(%rsp),%rax
cmp    0xc0(%rsp),%rdx
je     14fb <calculate_glszm+0x3db>
test   %r11d,%r11d
je     16f0 <calculate_glszm+0x5d0>
xor    %edi,%edi
mov    %r9,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq (%rax,%rdi,4),%rcx
mov    (%r15,%rdi,8),%rbp
add    %rcx,%rbp
movslq 0x0(%r13,%rdi,4),%rbx
cmp    %rbx,%rbp
jb     16f0 <calculate_glszm+0x5d0>
movslq 0x4(%r10,%rdi,4),%rbx
cmp    %rbx,%rbp
ja     16f0 <calculate_glszm+0x5d0>
movslq (%r12,%rdi,4),%rbp
imul   %rcx,%rbp
add    %rbp,%rsi
add    $0x1,%rdi
cmp    %rdi,%r8
jne    1720 <calculate_glszm+0x600>
cmp    %r9,%rsi
je     16f0 <calculate_glszm+0x5d0>
cmpb   $0x0,(%r14,%rsi,1)
je     16f0 <calculate_glszm+0x5d0>
mov    0x78(%rsp),%rcx
mov    0x34(%rsp),%edi
cmp    %edi,(%rcx,%rsi,4)
jne    16f0 <calculate_glszm+0x5d0>
cmpq   $0x0,0x20(%rsp)
je     16d1 <calculate_glszm+0x5b1>
mov    0x18(%rsp),%rdi
cmp    0x48(%rsp),%rdi
jb     16bf <calculate_glszm+0x59f>
jmp    1899 <calculate_glszm+0x779>
xchg   %ax,%ax
mov    0x38(%rsp),%rcx
cmp    0x68(%rsp),%rcx
jae    1899 <calculate_glszm+0x779>
mov    0xc(%rsp),%eax
cmp    %eax,%edi
cmovg  %edi,%eax
mov    %eax,0xc(%rsp)
mov    0x110(%rsp),%rax
mov    0x34(%rsp),%esi
mov    %esi,(%rax,%rcx,8)
mov    %edi,0x4(%rax,%rcx,8)
add    $0x1,%rcx
mov    %rcx,0x38(%rsp)
mov    0x20(%rsp),%rbp
jmp    1360 <calculate_glszm+0x240>
xor    %eax,%eax
mov    %rax,0x18(%rsp)
movl   $0x0,0xc(%rsp)
xor    %eax,%eax
mov    %rax,0x38(%rsp)
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
test   %rdi,%rdi
je     1873 <calculate_glszm+0x753>
mov    0x18(%rsp),%rsi
test   %rsi,%rsi
je     186e <calculate_glszm+0x74e>
lea    -0x1(%rsi),%rax
mov    %rsi,%rcx
and    $0x3,%rcx
je     1834 <calculate_glszm+0x714>
nopl   0x0(%rax)
mov    -0x8(%rdi,%rsi,8),%rdx
add    $0xffffffffffffffff,%rsi
movb   $0x1,(%r14,%rdx,1)
add    $0xffffffffffffffff,%rcx
jne    1820 <calculate_glszm+0x700>
cmp    $0x3,%rax
jb     186e <calculate_glszm+0x74e>
nopw   0x0(%rax,%rax,1)
mov    -0x8(%rdi,%rsi,8),%rax
movb   $0x1,(%r14,%rax,1)
mov    -0x10(%rdi,%rsi,8),%rax
movb   $0x1,(%r14,%rax,1)
mov    -0x18(%rdi,%rsi,8),%rax
movb   $0x1,(%r14,%rax,1)
mov    -0x20(%rdi,%rsi,8),%rax
movb   $0x1,(%r14,%rax,1)
add    $0xfffffffffffffffc,%rsi
jne    1840 <calculate_glszm+0x720>
call   1030 <free@plt>
mov    $0xffffffff,%eax
mov    0x38(%rsp),%rcx
cmp    0x68(%rsp),%rcx
jae    18b0 <calculate_glszm+0x790>
mov    0x110(%rsp),%rax
movl   $0xffffffff,(%rax,%rcx,8)
mov    0xc(%rsp),%eax
jmp    18b0 <calculate_glszm+0x790>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    $0xffffffff,%eax
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @calculate_glszm(i32* %0, i8* %1, i32* %2, i32* %3, i32* %4, i32* %5, i32 %6, i32 %7, i32* %8, i32 %9, i32 %10, i32 %11) {
%13 = alloca i32
%14 = alloca i32*
%15 = alloca i8*
%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 i64
%27 = alloca i64
%28 = alloca i64
%29 = alloca i64
%30 = alloca i64*
%31 = alloca i64*
%32 = alloca i64
%33 = alloca i64*
%34 = alloca i64
%35 = alloca i64
%36 = alloca i64
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i64
%41 = alloca i64
store i32* %0, i32** %14
store i8* %1, i8** %15
store i32* %2, i32** %16
store i32* %3, i32** %17
store i32* %4, i32** %18
store i32* %5, i32** %19
store i32 %6, i32* %20
store i32 %7, i32* %21
store i32* %8, i32** %22
store i32 %9, i32* %23
store i32 %10, i32* %24
store i32 %11, i32* %25
%42 = load i32, i32* %21
%43 = sext i32 %42 to i64
%44 = mul i64 8, %43
%45 = trunc i64 %44 to i32
%46 = call i64 @malloc(i32 %45)
%47 = inttoptr i64 %46 to i64*
store i64* %47, i64** %30
store i64 0, i64* %32
store i64* null, i64** %33
store i64 0, i64* %34
store i32 0, i32* %39
store i64 0, i64* %40
%48 = load i32, i32* %24
%49 = mul nsw i32 %48, 2
%50 = sext i32 %49 to i64
store i64 %50, i64* %41
%51 = load i32, i32* %24
%52 = sext i32 %51 to i64
%53 = mul i64 8, %52
%54 = trunc i64 %53 to i32
%55 = call i64 @malloc(i32 %54)
%56 = inttoptr i64 %55 to i64*
store i64* %56, i64** %31
%57 = load i32, i32* %25
%58 = icmp sgt i32 %57, 1
br i1 %58, label %59, label %66
59: ; preds = %12
%60 = load i32, i32* %24
%61 = sext i32 %60 to i64
%62 = mul i64 8, %61
%63 = trunc i64 %62 to i32
%64 = call i64 @malloc(i32 %63)
%65 = inttoptr i64 %64 to i64*
store i64* %65, i64** %33
br label %66
66: ; preds = %59, %12
%67 = load i32*, i32** %16
%68 = getelementptr inbounds i32, i32* %67, i64 0
%69 = load i32, i32* %68
%70 = sext i32 %69 to i64
store i64 %70, i64* %26
%71 = load i32*, i32** %17
%72 = getelementptr inbounds i32, i32* %71, i64 0
%73 = load i32, i32* %72
%74 = load i32*, i32** %18
%75 = getelementptr inbounds i32, i32* %74, i64 0
%76 = load i32, i32* %75
%77 = mul nsw i32 %73, %76
%78 = sext i32 %77 to i64
store i64 %78, i64* %27
store i64 1, i64* %36
br label %79
79: ; preds = %104, %66
%80 = load i64, i64* %36
%81 = load i32, i32* %21
%82 = sext i32 %81 to i64
%83 = icmp ult i64 %80, %82
br i1 %83, label %84, label %107
84: ; preds = %79
%85 = load i32*, i32** %17
%86 = load i64, i64* %36
%87 = getelementptr inbounds i32, i32* %85, i64 %86
%88 = load i32, i32* %87
%89 = load i32*, i32** %18
%90 = load i64, i64* %36
%91 = getelementptr inbounds i32, i32* %89, i64 %90
%92 = load i32, i32* %91
%93 = mul nsw i32 %88, %92
%94 = sext i32 %93 to i64
%95 = load i64, i64* %27
%96 = add i64 %95, %94
store i64 %96, i64* %27
%97 = load i32*, i32** %16
%98 = load i64, i64* %36
%99 = getelementptr inbounds i32, i32* %97, i64 %98
%100 = load i32, i32* %99
%101 = sext i32 %100 to i64
%102 = load i64, i64* %26
%103 = mul i64 %102, %101
store i64 %103, i64* %26
br label %104
104: ; preds = %84
%105 = load i64, i64* %36
%106 = add i64 %105, 1
store i64 %106, i64* %36
br label %79
107: ; preds = %79
br label %108
108: ; preds = %472, %107
%109 = load i64, i64* %27
%110 = load i64, i64* %26
%111 = icmp ult i64 %109, %110
br i1 %111, label %112, label %475
112: ; preds = %108
%113 = load i32, i32* %21
%114 = sub nsw i32 %113, 1
%115 = sext i32 %114 to i64
store i64 %115, i64* %36
br label %116
116: ; preds = %207, %112
%117 = load i64, i64* %36
%118 = icmp ugt i64 %117, 0
br i1 %118, label %119, label %210
119: ; preds = %116
%120 = load i64, i64* %27
%121 = load i32*, i32** %18
%122 = load i64, i64* %36
%123 = sub i64 %122, 1
%124 = getelementptr inbounds i32, i32* %121, i64 %123
%125 = load i32, i32* %124
%126 = sext i32 %125 to i64
%127 = urem i64 %120, %126
%128 = load i32*, i32** %18
%129 = load i64, i64* %36
%130 = getelementptr inbounds i32, i32* %128, i64 %129
%131 = load i32, i32* %130
%132 = sext i32 %131 to i64
%133 = udiv i64 %127, %132
%134 = load i64*, i64** %30
%135 = load i64, i64* %36
%136 = getelementptr inbounds i64, i64* %134, i64 %135
store i64 %133, i64* %136
%137 = load i64*, i64** %30
%138 = load i64, i64* %36
%139 = getelementptr inbounds i64, i64* %137, i64 %138
%140 = load i64, i64* %139
%141 = load i32*, i32** %17
%142 = load i32, i32* %21
%143 = sext i32 %142 to i64
%144 = load i64, i64* %36
%145 = add i64 %143, %144
%146 = getelementptr inbounds i32, i32* %141, i64 %145
%147 = load i32, i32* %146
%148 = sext i32 %147 to i64
%149 = icmp ugt i64 %140, %148
br i1 %149, label %150, label %175
150: ; preds = %119
%151 = load i32*, i32** %16
%152 = load i64, i64* %36
%153 = getelementptr inbounds i32, i32* %151, i64 %152
%154 = load i32, i32* %153
%155 = sext i32 %154 to i64
%156 = load i64*, i64** %30
%157 = load i64, i64* %36
%158 = getelementptr inbounds i64, i64* %156, i64 %157
%159 = load i64, i64* %158
%160 = sub i64 %155, %159
%161 = load i32*, i32** %17
%162 = load i64, i64* %36
%163 = getelementptr inbounds i32, i32* %161, i64 %162
%164 = load i32, i32* %163
%165 = sext i32 %164 to i64
%166 = add i64 %160, %165
%167 = load i32*, i32** %18
%168 = load i64, i64* %36
%169 = getelementptr inbounds i32, i32* %167, i64 %168
%170 = load i32, i32* %169
%171 = sext i32 %170 to i64
%172 = mul i64 %166, %171
%173 = load i64, i64* %27
%174 = add i64 %173, %172
store i64 %174, i64* %27
br label %206
175: ; preds = %119
%176 = load i64*, i64** %30
%177 = load i64, i64* %36
%178 = getelementptr inbounds i64, i64* %176, i64 %177
%179 = load i64, i64* %178
%180 = load i32*, i32** %17
%181 = load i64, i64* %36
%182 = getelementptr inbounds i32, i32* %180, i64 %181
%183 = load i32, i32* %182
%184 = sext i32 %183 to i64
%185 = icmp ult i64 %179, %184
br i1 %185, label %186, label %205
186: ; preds = %175
%187 = load i32*, i32** %17
%188 = load i64, i64* %36
%189 = getelementptr inbounds i32, i32* %187, i64 %188
%190 = load i32, i32* %189
%191 = sext i32 %190 to i64
%192 = load i64*, i64** %30
%193 = load i64, i64* %36
%194 = getelementptr inbounds i64, i64* %192, i64 %193
%195 = load i64, i64* %194
%196 = sub i64 %191, %195
%197 = load i32*, i32** %18
%198 = load i64, i64* %36
%199 = getelementptr inbounds i32, i32* %197, i64 %198
%200 = load i32, i32* %199
%201 = sext i32 %200 to i64
%202 = mul i64 %196, %201
%203 = load i64, i64* %27
%204 = add i64 %203, %202
store i64 %204, i64* %27
br label %205
205: ; preds = %186, %175
br label %206
206: ; preds = %205, %150
br label %207
207: ; preds = %206
%208 = load i64, i64* %36
%209 = add i64 %208, -1
store i64 %209, i64* %36
br label %116
210: ; preds = %116
%211 = load i64, i64* %27
%212 = load i32*, i32** %18
%213 = getelementptr inbounds i32, i32* %212, i64 0
%214 = load i32, i32* %213
%215 = sext i32 %214 to i64
%216 = udiv i64 %211, %215
%217 = load i32*, i32** %17
%218 = load i32, i32* %21
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds i32, i32* %217, i64 %219
%221 = load i32, i32* %220
%222 = sext i32 %221 to i64
%223 = icmp ugt i64 %216, %222
br i1 %223, label %224, label %225
224: ; preds = %210
br label %475
225: ; preds = %210
%226 = load i8*, i8** %15
%227 = load i64, i64* %27
%228 = getelementptr inbounds i8, i8* %226, i64 %227
%229 = load i8, i8* %228
%230 = icmp ne i8 %229, 0
br i1 %230, label %231, label %471
231: ; preds = %225
%232 = load i32*, i32** %14
%233 = load i64, i64* %27
%234 = getelementptr inbounds i32, i32* %232, i64 %233
%235 = load i32, i32* %234
store i32 %235, i32* %37
store i32 0, i32* %38
%236 = load i64*, i64** %33
%237 = icmp ne i64* %236, null
br i1 %237, label %238, label %254
238: ; preds = %231
%239 = load i64, i64* %34
%240 = load i32, i32* %24
%241 = sext i32 %240 to i64
%242 = icmp uge i64 %239, %241
br i1 %242, label %243, label %248
243: ; preds = %238
%244 = load i64*, i64** %30
%245 = call i32 @free(i64* %244)
%246 = load i64*, i64** %31
%247 = call i32 @free(i64* %246)
store i32 -1, i32* %13
br label %508
248: ; preds = %238
%249 = load i64, i64* %27
%250 = load i64*, i64** %33
%251 = load i64, i64* %34
%252 = add i64 %251, 1
store i64 %252, i64* %34
%253 = getelementptr inbounds i64, i64* %250, i64 %251
store i64 %249, i64* %253
br label %254
254: ; preds = %248, %231
%255 = load i64, i64* %27
%256 = load i64*, i64** %31
%257 = load i64, i64* %32
%258 = add i64 %257, 1
store i64 %258, i64* %32
%259 = getelementptr inbounds i64, i64* %256, i64 %257
store i64 %255, i64* %259
%260 = load i8*, i8** %15
%261 = load i64, i64* %27
%262 = getelementptr inbounds i8, i8* %260, i64 %261
store i8 0, i8* %262
br label %263
263: ; preds = %441, %254
%264 = load i64, i64* %32
%265 = icmp ugt i64 %264, 0
br i1 %265, label %266, label %442
266: ; preds = %263
%267 = load i64*, i64** %31
%268 = load i64, i64* %32
%269 = add i64 %268, -1
store i64 %269, i64* %32
%270 = getelementptr inbounds i64, i64* %267, i64 %269
%271 = load i64, i64* %270
store i64 %271, i64* %29
%272 = load i32, i32* %38
%273 = add nsw i32 %272, 1
store i32 %273, i32* %38
%274 = load i64, i64* %29
%275 = load i32*, i32** %18
%276 = getelementptr inbounds i32, i32* %275, i64 0
%277 = load i32, i32* %276
%278 = sext i32 %277 to i64
%279 = udiv i64 %274, %278
%280 = load i64*, i64** %30
%281 = getelementptr inbounds i64, i64* %280, i64 0
store i64 %279, i64* %281
store i64 1, i64* %36
br label %282
282: ; preds = %305, %266
%283 = load i64, i64* %36
%284 = load i32, i32* %21
%285 = sext i32 %284 to i64
%286 = icmp ult i64 %283, %285
br i1 %286, label %287, label %308
287: ; preds = %282
%288 = load i64, i64* %29
%289 = load i32*, i32** %18
%290 = load i64, i64* %36
%291 = sub i64 %290, 1
%292 = getelementptr inbounds i32, i32* %289, i64 %291
%293 = load i32, i32* %292
%294 = sext i32 %293 to i64
%295 = urem i64 %288, %294
%296 = load i32*, i32** %18
%297 = load i64, i64* %36
%298 = getelementptr inbounds i32, i32* %296, i64 %297
%299 = load i32, i32* %298
%300 = sext i32 %299 to i64
%301 = udiv i64 %295, %300
%302 = load i64*, i64** %30
%303 = load i64, i64* %36
%304 = getelementptr inbounds i64, i64* %302, i64 %303
store i64 %301, i64* %304
br label %305
305: ; preds = %287
%306 = load i64, i64* %36
%307 = add i64 %306, 1
store i64 %307, i64* %36
br label %282
308: ; preds = %282
store i64 0, i64* %35
br label %309
309: ; preds = %438, %308
%310 = load i64, i64* %35
%311 = load i32, i32* %20
%312 = sext i32 %311 to i64
%313 = icmp ult i64 %310, %312
br i1 %313, label %314, label %441
314: ; preds = %309
%315 = load i64, i64* %29
store i64 %315, i64* %28
store i64 0, i64* %36
br label %316
316: ; preds = %388, %314
%317 = load i64, i64* %36
%318 = load i32, i32* %21
%319 = sext i32 %318 to i64
%320 = icmp ult i64 %317, %319
br i1 %320, label %321, label %391
321: ; preds = %316
%322 = load i64*, i64** %30
%323 = load i64, i64* %36
%324 = getelementptr inbounds i64, i64* %322, i64 %323
%325 = load i64, i64* %324
%326 = load i32*, i32** %19
%327 = load i64, i64* %35
%328 = load i32, i32* %21
%329 = sext i32 %328 to i64
%330 = mul i64 %327, %329
%331 = load i64, i64* %36
%332 = add i64 %330, %331
%333 = getelementptr inbounds i32, i32* %326, i64 %332
%334 = load i32, i32* %333
%335 = sext i32 %334 to i64
%336 = add i64 %325, %335
%337 = load i32*, i32** %17
%338 = load i64, i64* %36
%339 = getelementptr inbounds i32, i32* %337, i64 %338
%340 = load i32, i32* %339
%341 = sext i32 %340 to i64
%342 = icmp ult i64 %336, %341
br i1 %342, label %368, label %343
343: ; preds = %321
%344 = load i64*, i64** %30
%345 = load i64, i64* %36
%346 = getelementptr inbounds i64, i64* %344, i64 %345
%347 = load i64, i64* %346
%348 = load i32*, i32** %19
%349 = load i64, i64* %35
%350 = load i32, i32* %21
%351 = sext i32 %350 to i64
%352 = mul i64 %349, %351
%353 = load i64, i64* %36
%354 = add i64 %352, %353
%355 = getelementptr inbounds i32, i32* %348, i64 %354
%356 = load i32, i32* %355
%357 = sext i32 %356 to i64
%358 = add i64 %347, %357
%359 = load i32*, i32** %17
%360 = load i32, i32* %21
%361 = sext i32 %360 to i64
%362 = load i64, i64* %36
%363 = add i64 %361, %362
%364 = getelementptr inbounds i32, i32* %359, i64 %363
%365 = load i32, i32* %364
%366 = sext i32 %365 to i64
%367 = icmp ugt i64 %358, %366
br i1 %367, label %368, label %370
368: ; preds = %343, %321
%369 = load i64, i64* %29
store i64 %369, i64* %28
br label %391
370: ; preds = %343
%371 = load i32*, i32** %19
%372 = load i64, i64* %35
%373 = load i32, i32* %21
%374 = sext i32 %373 to i64
%375 = mul i64 %372, %374
%376 = load i64, i64* %36
%377 = add i64 %375, %376
%378 = getelementptr inbounds i32, i32* %371, i64 %377
%379 = load i32, i32* %378
%380 = load i32*, i32** %18
%381 = load i64, i64* %36
%382 = getelementptr inbounds i32, i32* %380, i64 %381
%383 = load i32, i32* %382
%384 = mul nsw i32 %379, %383
%385 = sext i32 %384 to i64
%386 = load i64, i64* %28
%387 = add i64 %386, %385
store i64 %387, i64* %28
br label %388
388: ; preds = %370
%389 = load i64, i64* %36
%390 = add i64 %389, 1
store i64 %390, i64* %36
br label %316
391: ; preds = %368, %316
%392 = load i64, i64* %28
%393 = load i64, i64* %29
%394 = icmp ne i64 %392, %393
br i1 %394, label %395, label %437
395: ; preds = %391
%396 = load i8*, i8** %15
%397 = load i64, i64* %28
%398 = getelementptr inbounds i8, i8* %396, i64 %397
%399 = load i8, i8* %398
%400 = sext i8 %399 to i32
%401 = icmp ne i32 %400, 0
br i1 %401, label %402, label %437
402: ; preds = %395
%403 = load i32*, i32** %14
%404 = load i64, i64* %28
%405 = getelementptr inbounds i32, i32* %403, i64 %404
%406 = load i32, i32* %405
%407 = load i32, i32* %37
%408 = icmp eq i32 %406, %407
br i1 %408, label %409, label %437
409: ; preds = %402
%410 = load i64*, i64** %33
%411 = icmp ne i64* %410, null
br i1 %411, label %412, label %428
412: ; preds = %409
%413 = load i64, i64* %34
%414 = load i32, i32* %24
%415 = sext i32 %414 to i64
%416 = icmp uge i64 %413, %415
br i1 %416, label %417, label %422
417: ; preds = %412
%418 = load i64*, i64** %30
%419 = call i32 @free(i64* %418)
%420 = load i64*, i64** %31
%421 = call i32 @free(i64* %420)
store i32 -1, i32* %13
br label %508
422: ; preds = %412
%423 = load i64, i64* %28
%424 = load i64*, i64** %33
%425 = load i64, i64* %34
%426 = add i64 %425, 1
store i64 %426, i64* %34
%427 = getelementptr inbounds i64, i64* %424, i64 %425
store i64 %423, i64* %427
br label %428
428: ; preds = %422, %409
%429 = load i64, i64* %28
%430 = load i64*, i64** %31
%431 = load i64, i64* %32
%432 = add i64 %431, 1
store i64 %432, i64* %32
%433 = getelementptr inbounds i64, i64* %430, i64 %431
store i64 %429, i64* %433
%434 = load i8*, i8** %15
%435 = load i64, i64* %28
%436 = getelementptr inbounds i8, i8* %434, i64 %435
store i8 0, i8* %436
br label %437
437: ; preds = %428, %402, %395, %391
br label %438
438: ; preds = %437
%439 = load i64, i64* %35
%440 = add i64 %439, 1
store i64 %440, i64* %35
br label %309
441: ; preds = %309
br label %263
442: ; preds = %263
%443 = load i64, i64* %40
%444 = load i64, i64* %41
%445 = icmp uge i64 %443, %444
br i1 %445, label %446, label %451
446: ; preds = %442
%447 = load i64*, i64** %30
%448 = call i32 @free(i64* %447)
%449 = load i64*, i64** %31
%450 = call i32 @free(i64* %449)
store i32 -1, i32* %13
br label %508
451: ; preds = %442
%452 = load i32, i32* %38
%453 = load i32, i32* %39
%454 = icmp sgt i32 %452, %453
br i1 %454, label %455, label %457
455: ; preds = %451
%456 = load i32, i32* %38
store i32 %456, i32* %39
br label %457
457: ; preds = %455, %451
%458 = load i32, i32* %37
%459 = load i32*, i32** %22
%460 = load i64, i64* %40
%461 = mul i64 %460, 2
%462 = getelementptr inbounds i32, i32* %459, i64 %461
store i32 %458, i32* %462
%463 = load i32, i32* %38
%464 = load i32*, i32** %22
%465 = load i64, i64* %40
%466 = mul i64 %465, 2
%467 = add i64 %466, 1
%468 = getelementptr inbounds i32, i32* %464, i64 %467
store i32 %463, i32* %468
%469 = load i64, i64* %40
%470 = add i64 %469, 1
store i64 %470, i64* %40
br label %471
471: ; preds = %457, %225
br label %472
472: ; preds = %471
%473 = load i64, i64* %27
%474 = add i64 %473, 1
store i64 %474, i64* %27
br label %108
475: ; preds = %224, %108
%476 = load i64*, i64** %30
%477 = call i32 @free(i64* %476)
%478 = load i64*, i64** %31
%479 = call i32 @free(i64* %478)
%480 = load i64*, i64** %33
%481 = icmp ne i64* %480, null
br i1 %481, label %482, label %497
482: ; preds = %475
br label %483
483: ; preds = %486, %482
%484 = load i64, i64* %34
%485 = icmp ugt i64 %484, 0
br i1 %485, label %486, label %494
486: ; preds = %483
%487 = load i8*, i8** %15
%488 = load i64*, i64** %33
%489 = load i64, i64* %34
%490 = add i64 %489, -1
store i64 %490, i64* %34
%491 = getelementptr inbounds i64, i64* %488, i64 %490
%492 = load i64, i64* %491
%493 = getelementptr inbounds i8, i8* %487, i64 %492
store i8 1, i8* %493
br label %483
494: ; preds = %483
%495 = load i64*, i64** %33
%496 = call i32 @free(i64* %495)
br label %497
497: ; preds = %494, %475
%498 = load i64, i64* %40
%499 = load i64, i64* %41
%500 = icmp uge i64 %498, %499
br i1 %500, label %501, label %502
501: ; preds = %497
store i32 -1, i32* %13
br label %508
502: ; preds = %497
%503 = load i32*, i32** %22
%504 = load i64, i64* %40
%505 = mul i64 %504, 2
%506 = getelementptr inbounds i32, i32* %503, i64 %505
store i32 -1, i32* %506
%507 = load i32, i32* %39
store i32 %507, i32* %13
br label %508
508: ; preds = %502, %501, %446, %417, %243
%509 = load i32, i32* %13
ret i32 %509
}

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