#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_gldm(int *image, char *mask, int *size, int *bb, int *strides,
                   int *angles, int Na, int Nd, double *gldm, int Ng,
                   int alpha) {
  size_t Ni;
  size_t i, j;
  size_t *cur_idx = (size_t *)malloc(sizeof *cur_idx * Nd);
  size_t a, d;
  int dep, diff;
  size_t gldm_idx, gldm_idx_max = Ng * (Na * 2 + 1);
  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];
        cur_idx[d] = bb[d];
      } else if (cur_idx[d] < bb[d]) {
        i += (bb[d] - cur_idx[d]) * strides[d];
        cur_idx[d] = bb[d];
      }
    }
    cur_idx[0] = i / strides[0];
    if (cur_idx[0] > bb[Nd])
      break;
    if (mask[i]) {
      dep = 0;
      for (a = 0; a < Na; a++) {
        j = i;
        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 = i;
            break;
          }
          j += angles[a * Nd + d] * strides[d];
        }
        if (j != i && mask[j]) {
          diff = image[i] - image[j];
          if (diff < 0)
            diff *= -1;
          if (diff <= alpha)
            dep++;
        }
      }
      gldm_idx = dep + (image[i] - 1) * (Na * 2 + 1);
      if (image[i] <= 0 || gldm_idx >= gldm_idx_max) {
        free(cur_idx);
        return 0;
      }
      gldm[gldm_idx]++;
    }
  }
  free(cur_idx);
  return 1;
}


x86 assembly (clang, -O0):
<calculate_gldm>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
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,-0x58(%rbp)
mov    0x28(%rbp),%eax
mov    0x10(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
cltq
mov    %rax,-0x80(%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,-0x68(%rbp)
mov    -0x68(%rbp),%rax
movslq 0x18(%rbp),%rcx
cmp    %rcx,%rax
jae    11f9 <calculate_gldm+0xd9>
mov    -0x28(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x30(%rbp),%rcx
mov    -0x68(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
cltq
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x68(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
imul   -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    11a1 <calculate_gldm+0x81>
jmp    11fe <calculate_gldm+0xde>
mov    -0x48(%rbp),%rax
cmp    -0x40(%rbp),%rax
jae    15c0 <calculate_gldm+0x4a0>
mov    0x18(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %rax,-0x68(%rbp)
cmpq   $0x0,-0x68(%rbp)
jbe    1364 <calculate_gldm+0x244>
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x68(%rbp),%rdx
sub    $0x1,%rdx
movslq (%rcx,%rdx,4),%rcx
xor    %edx,%edx
div    %rcx
mov    %rdx,%rax
mov    -0x30(%rbp),%rcx
mov    -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
xor    %edx,%edx
div    %rcx
mov    %rax,%rdx
mov    -0x58(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
movslq 0x18(%rbp),%rdx
add    -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
cmp    %rcx,%rax
jbe    12e0 <calculate_gldm+0x1c0>
mov    -0x20(%rbp),%rax
mov    -0x68(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
mov    -0x58(%rbp),%rcx
mov    -0x68(%rbp),%rdx
sub    (%rcx,%rdx,8),%rax
mov    -0x28(%rbp),%rcx
mov    -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%rcx
mov    -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
imul   %rcx,%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x68(%rbp),%rcx
movslq (%rax,%rcx,4),%rdx
mov    -0x58(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    134e <calculate_gldm+0x22e>
mov    -0x58(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
mov    -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
cmp    %rcx,%rax
jae    1349 <calculate_gldm+0x229>
mov    -0x28(%rbp),%rax
mov    -0x68(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
mov    -0x58(%rbp),%rcx
mov    -0x68(%rbp),%rdx
sub    (%rcx,%rdx,8),%rax
mov    -0x30(%rbp),%rcx
mov    -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
imul   %rcx,%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x68(%rbp),%rcx
movslq (%rax,%rcx,4),%rdx
mov    -0x58(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    134e <calculate_gldm+0x22e>
jmp    1353 <calculate_gldm+0x233>
mov    -0x68(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x68(%rbp)
jmp    1218 <calculate_gldm+0xf8>
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
xor    %edx,%edx
div    %rcx
mov    %rax,%rcx
mov    -0x58(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x58(%rbp),%rax
mov    (%rax),%rax
mov    -0x28(%rbp),%rcx
movslq 0x18(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
cmp    %rcx,%rax
jbe    139f <calculate_gldm+0x27f>
jmp    15c0 <calculate_gldm+0x4a0>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
je     15aa <calculate_gldm+0x48a>
movl   $0x0,-0x6c(%rbp)
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
movslq 0x10(%rbp),%rcx
cmp    %rcx,%rax
jae    1536 <calculate_gldm+0x416>
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
movslq 0x18(%rbp),%rcx
cmp    %rcx,%rax
jae    14b9 <calculate_gldm+0x399>
mov    -0x58(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%rcx
mov    -0x60(%rbp),%rdx
movslq 0x18(%rbp),%rsi
imul   %rsi,%rdx
add    -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
add    %rcx,%rax
mov    -0x28(%rbp),%rcx
mov    -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
cmp    %rcx,%rax
jb     146e <calculate_gldm+0x34e>
mov    -0x58(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%rcx
mov    -0x60(%rbp),%rdx
movslq 0x18(%rbp),%rsi
imul   %rsi,%rdx
add    -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
add    %rcx,%rax
mov    -0x28(%rbp),%rcx
movslq 0x18(%rbp),%rdx
add    -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
cmp    %rcx,%rax
jbe    147b <calculate_gldm+0x35b>
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
jmp    14b9 <calculate_gldm+0x399>
mov    -0x38(%rbp),%rax
mov    -0x60(%rbp),%rcx
movslq 0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x30(%rbp),%rcx
mov    -0x68(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
cltq
add    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    13e1 <calculate_gldm+0x2c1>
mov    -0x50(%rbp),%rax
cmp    -0x48(%rbp),%rax
je     1520 <calculate_gldm+0x400>
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1520 <calculate_gldm+0x400>
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x50(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x70(%rbp)
cmpl   $0x0,-0x70(%rbp)
jge    1506 <calculate_gldm+0x3e6>
imul   $0xffffffff,-0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    0x30(%rbp),%eax
jg     151b <calculate_gldm+0x3fb>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1520 <calculate_gldm+0x400>
jmp    1525 <calculate_gldm+0x405>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    13c0 <calculate_gldm+0x2a0>
mov    -0x6c(%rbp),%eax
mov    -0x10(%rbp),%rcx
mov    -0x48(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
mov    0x10(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
imul   %edx,%ecx
add    %ecx,%eax
cltq
mov    %rax,-0x78(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    157b <calculate_gldm+0x45b>
mov    -0x78(%rbp),%rax
cmp    -0x80(%rbp),%rax
jb     1590 <calculate_gldm+0x470>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
jmp    15d0 <calculate_gldm+0x4b0>
mov    0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
movsd  0xa60(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    15af <calculate_gldm+0x48f>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    11fe <calculate_gldm+0xde>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calculate_gldm>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r9,0x38(%rsp)
mov    %r8,%r13
mov    %rcx,%r15
mov    %rdx,%rbp
mov    %rsi,0x10(%rsp)
mov    %rdi,0x28(%rsp)
movslq 0xc8(%rsp),%rbx
lea    0x0(,%rbx,8),%edi
call   1040 <malloc@plt>
mov    %rbp,%r10
mov    %rax,%r14
movslq (%r15),%r12
movslq 0x0(%r13),%r8
imul   %r8,%r12
movslq 0x0(%rbp),%rbp
cmp    $0x2,%rbx
mov    %rbx,(%rsp)
jb     1205 <calculate_gldm+0xe5>
lea    -0x1(%rbx),%rdx
cmp    $0x2,%ebx
jne    1190 <calculate_gldm+0x70>
mov    $0x1,%eax
jmp    11e4 <calculate_gldm+0xc4>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
mov    $0x1,%eax
nop
movslq (%r15,%rax,4),%rcx
movslq 0x0(%r13,%rax,4),%rdi
imul   %rcx,%rdi
add    %r12,%rdi
movslq (%r10,%rax,4),%rcx
imul   %rbp,%rcx
movslq 0x4(%r15,%rax,4),%rbx
movslq 0x4(%r13,%rax,4),%r12
imul   %rbx,%r12
add    %rdi,%r12
movslq 0x4(%r10,%rax,4),%rbp
imul   %rcx,%rbp
lea    (%rsi,%rax,1),%rcx
add    $0x2,%rcx
add    $0x2,%rax
cmp    $0x1,%rcx
jne    11a0 <calculate_gldm+0x80>
test   $0x1,%dl
mov    (%rsp),%rbx
je     1205 <calculate_gldm+0xe5>
movslq (%r15,%rax,4),%rcx
movslq 0x0(%r13,%rax,4),%rdx
imul   %rcx,%rdx
add    %rdx,%r12
movslq (%r10,%rax,4),%rax
imul   %rax,%rbp
mov    %r8,0x58(%rsp)
mov    %rbp,0x50(%rsp)
cmp    %rbp,%r12
jae    1536 <calculate_gldm+0x416>
mov    0xc0(%rsp),%edx
lea    (%rdx,%rdx,1),%eax
add    $0x1,%eax
mov    0xd8(%rsp),%ecx
mov    %eax,0x1c(%rsp)
imul   %eax,%ecx
mov    %ecx,0x18(%rsp)
movslq %ebx,%rax
lea    -0x1(%rax),%rcx
mov    %rcx,0x48(%rsp)
cmp    $0x2,%rbx
mov    $0x1,%esi
mov    $0x1,%r9d
cmovae %rbx,%r9
cmp    $0x2,%edx
mov    $0x1,%ecx
cmovae %edx,%ecx
movslq %ecx,%rcx
mov    %rcx,0x70(%rsp)
lea    -0x4(%r15,%rax,4),%rdi
lea    -0x4(%r10,%rax,4),%rcx
mov    %rcx,0x60(%rsp)
lea    -0x1(%rbx,%rax,1),%rcx
lea    (%r15,%rcx,4),%rcx
mov    %rcx,0x80(%rsp)
lea    (%r14,%rax,8),%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,0x30(%rsp)
sub    %rax,%rsi
lea    -0x8(,%rax,4),%rax
ff
add    %r13,%rax
mov    %rax,0x78(%rsp)
mov    %rbx,%rax
shl    $0x2,%rax
mov    %rax,0x68(%rsp)
movsd  0xd43(%rip),%xmm0
lea    (%r15,%rbx,4),%r8
movslq (%r15,%rbx,4),%rax
mov    %rax,0x40(%rsp)
mov    %r13,0x20(%rsp)
jmp    1307 <calculate_gldm+0x1e7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cltq
mov    0xd0(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rax,8)
add    $0x1,%r12
cmp    0x50(%rsp),%r12
jae    1536 <calculate_gldm+0x416>
mov    0x48(%rsp),%rax
test   %eax,%eax
je     13e0 <calculate_gldm+0x2c0>
mov    0x0(%r13,%rax,4),%ebp
xor    %r13d,%r13d
jmp    1353 <calculate_gldm+0x233>
xchg   %ax,%ax
mov    0x60(%rsp),%rcx
movslq (%rcx,%r13,4),%rdx
sub    %rax,%rdx
movslq (%rdi,%r13,4),%rcx
add    %rcx,%rdx
imul   %r10,%rdx
add    %rdx,%r12
mov    0x30(%rsp),%rax
mov    %rcx,(%rax,%r13,8)
add    $0xffffffffffffffff,%r13
mov    %r11d,%ebp
cmp    %r13,%rsi
je     13e0 <calculate_gldm+0x2c0>
mov    0x78(%rsp),%rax
mov    (%rax,%r13,4),%r11d
movslq %r11d,%rcx
mov    %r12,%rax
or     %rcx,%rax
shr    $0x20,%rax
je     1380 <calculate_gldm+0x260>
mov    %r12,%rax
xor    %edx,%edx
div    %rcx
mov    %rdx,%rax
jmp    138a <calculate_gldm+0x26a>
nopl   0x0(%rax,%rax,1)
mov    %r12d,%eax
xor    %edx,%edx
div    %r11d
mov    %edx,%eax
movslq %ebp,%r10
mov    %rax,%rcx
or     %r10,%rcx
shr    $0x20,%rcx
je     13a0 <calculate_gldm+0x280>
xor    %edx,%edx
div    %r10
jmp    13a4 <calculate_gldm+0x284>
xor    %edx,%edx
div    %ebp
mov    0x30(%rsp),%rcx
mov    %rax,(%rcx,%r13,8)
mov    0x80(%rsp),%rcx
movslq (%rcx,%r13,4),%rcx
cmp    %rcx,%rax
ja     1320 <calculate_gldm+0x200>
movslq (%rdi,%r13,4),%rcx
cmp    %rcx,%rax
jae    1343 <calculate_gldm+0x223>
mov    %rcx,%rdx
sub    %rax,%rdx
jmp    1333 <calculate_gldm+0x213>
nopw   0x0(%rax,%rax,1)
mov    %r12,%rax
mov    0x58(%rsp),%rcx
or     %rcx,%rax
shr    $0x20,%rax
je     1400 <calculate_gldm+0x2e0>
mov    %r12,%rax
xor    %edx,%edx
div    %rcx
jmp    1407 <calculate_gldm+0x2e7>
nopl   0x0(%rax,%rax,1)
mov    %r12d,%eax
xor    %edx,%edx
div    %ecx
mov    0x20(%rsp),%r13
mov    0x10(%rsp),%rcx
mov    %rax,(%r14)
cmp    0x40(%rsp),%rax
ja     1536 <calculate_gldm+0x416>
cmpb   $0x0,(%rcx,%r12,1)
je     12f8 <calculate_gldm+0x1d8>
mov    0xc0(%rsp),%eax
test   %eax,%eax
je     1500 <calculate_gldm+0x3e0>
xor    %eax,%eax
mov    %rax,0x8(%rsp)
mov    0x38(%rsp),%rdx
xor    %ebp,%ebp
jmp    146e <calculate_gldm+0x34e>
nopl   0x0(%rax)
mov    (%rsp),%rbx
mov    %r10,%rsi
mov    %r11,%rdi
add    $0x1,%rbp
add    0x68(%rsp),%rdx
cmp    0x70(%rsp),%rbp
je     1507 <calculate_gldm+0x3e7>
test   %ebx,%ebx
je     145a <calculate_gldm+0x33a>
mov    %rdi,%r11
mov    %rsi,%r10
xor    %eax,%eax
mov    %r12,%rcx
nopl   (%rax)
movslq (%rdx,%rax,4),%rdi
mov    (%r14,%rax,8),%rbx
add    %rdi,%rbx
movslq (%r15,%rax,4),%rsi
cmp    %rsi,%rbx
jb     1450 <calculate_gldm+0x330>
movslq (%r8,%rax,4),%rsi
cmp    %rsi,%rbx
ja     1450 <calculate_gldm+0x330>
movslq 0x0(%r13,%rax,4),%rsi
imul   %rdi,%rsi
add    %rsi,%rcx
add    $0x1,%rax
cmp    %rax,%r9
jne    1480 <calculate_gldm+0x360>
cmp    %r12,%rcx
je     1450 <calculate_gldm+0x330>
mov    0x10(%rsp),%rax
cmpb   $0x0,(%rax,%rcx,1)
mov    %r11,%rdi
je     14f0 <calculate_gldm+0x3d0>
mov    0x28(%rsp),%rsi
mov    (%rsi,%r12,4),%eax
sub    (%rsi,%rcx,4),%eax
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
xor    %eax,%eax
cmp    0xe0(%rsp),%ecx
setle  %al
mov    0x8(%rsp),%rcx
add    %eax,%ecx
mov    %rcx,0x8(%rsp)
mov    (%rsp),%rbx
mov    %r10,%rsi
jmp    145a <calculate_gldm+0x33a>
nopl   0x0(%rax)
xor    %eax,%eax
mov    %rax,0x8(%rsp)
mov    0x28(%rsp),%rax
mov    (%rax,%r12,4),%eax
test   %eax,%eax
jle    152a <calculate_gldm+0x40a>
add    $0xffffffff,%eax
imul   0x1c(%rsp),%eax
add    0x8(%rsp),%eax
cmp    0x18(%rsp),%eax
jb     12e0 <calculate_gldm+0x1c0>
mov    %r14,%rdi
call   1030 <free@plt>
xor    %eax,%eax
jmp    1543 <calculate_gldm+0x423>
mov    %r14,%rdi
call   1030 <free@plt>
mov    $0x1,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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