#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 */
scalar_t__ calloc(int, int);
int extend_lower_part_of_window(int, int, int, int *);
int extend_upper_part_of_window(int, int, int, int *);
int /*<<< orphan*/ free(int *);
int get_blocks(int **block_coordinates, int genome_size, int *snp_site_coords,
               int number_of_branch_snps, int window_size, int cutoff,
               char *original_sequence, int *snp_locations,
               int number_of_snps) {
  int *window_count;
  window_count = (int *)calloc((genome_size + 1), sizeof(int));
  int *gaps_in_original_genome_space;
  gaps_in_original_genome_space = (int *)calloc((genome_size + 1), sizeof(int));
  int x = 0;
  for (x = 0; x < number_of_snps; x++) {
    if (original_sequence[x] == 'N' || original_sequence[x] == '-') {
      gaps_in_original_genome_space[snp_locations[x] - 1] = 1;
    }
  }
  int snp_counter = 0;
  for (snp_counter = 0; snp_counter < number_of_branch_snps; snp_counter++) {
    int j = 0;
    int snp_sliding_window_counter =
        snp_site_coords[snp_counter] - (window_size / 2);
    snp_sliding_window_counter = extend_lower_part_of_window(
        snp_site_coords[snp_counter] - 1, snp_sliding_window_counter,
        genome_size, gaps_in_original_genome_space);
    if (snp_sliding_window_counter < 0) {
      snp_sliding_window_counter = 0;
    }
    int max_snp_sliding_window_counter =
        snp_site_coords[snp_counter] + (window_size / 2);
    max_snp_sliding_window_counter = extend_upper_part_of_window(
        snp_site_coords[snp_counter] + 1, max_snp_sliding_window_counter,
        genome_size, gaps_in_original_genome_space);
    if (max_snp_sliding_window_counter > genome_size) {
      max_snp_sliding_window_counter = genome_size;
    }
    for (j = snp_sliding_window_counter; j < max_snp_sliding_window_counter;
         j++) {
      window_count[j] += 1;
    }
  }
  int number_of_blocks = 0;
  int in_block = 0;
  int block_lower_bound = 0;
  int i;
  for (i = 0; i < genome_size; i++) {
    if (window_count[i] > cutoff && in_block == 0) {
      block_lower_bound = i;
      in_block = 1;
    }
    if ((window_count[i] <= cutoff || i + 1 == genome_size) && in_block == 1) {
      block_coordinates[0][number_of_blocks] = block_lower_bound;
      block_coordinates[1][number_of_blocks] = i - 1;
      number_of_blocks++;
      in_block = 0;
    }
  }
  for (i = 0; i < number_of_blocks; i++) {
    for (snp_counter = 0; snp_counter < number_of_branch_snps; snp_counter++) {
      if (snp_site_coords[snp_counter] >= block_coordinates[0][i]) {
        block_coordinates[0][i] = snp_site_coords[snp_counter];
        break;
      }
    }
    for (snp_counter = number_of_branch_snps - 1; snp_counter >= 0;
         snp_counter--) {
      if (snp_site_coords[snp_counter] <= block_coordinates[1][i]) {
        block_coordinates[1][i] = snp_site_coords[snp_counter];
        break;
      }
    }
  }
  free(gaps_in_original_genome_space);
  free(window_count);
  return number_of_blocks;
}


x86 assembly (clang, -O0):
<get_blocks>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
mov    -0xc(%rbp),%edi
add    $0x1,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0xc(%rbp),%edi
add    $0x1,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1204 <get_blocks+0xc4>
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4e,%eax
je     11d5 <get_blocks+0x95>
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    11f1 <get_blocks+0xb1>
mov    -0x38(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    11f6 <get_blocks+0xb6>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    119f <get_blocks+0x5f>
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1312 <get_blocks+0x1d2>
movl   $0x0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x20(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x60(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
sub    $0x1,%edi
mov    -0x48(%rbp),%esi
mov    -0xc(%rbp),%edx
mov    -0x38(%rbp),%rcx
call   1040 <extend_lower_part_of_window@plt>
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x48(%rbp)
jge    1279 <get_blocks+0x139>
movl   $0x0,-0x48(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
mov    -0x20(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x64(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
add    $0x1,%edi
mov    -0x4c(%rbp),%esi
mov    -0xc(%rbp),%edx
mov    -0x38(%rbp),%rcx
call   1060 <extend_upper_part_of_window@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jle    12ce <get_blocks+0x18e>
mov    -0xc(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    12ff <get_blocks+0x1bf>
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12d4 <get_blocks+0x194>
jmp    1304 <get_blocks+0x1c4>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1212 <get_blocks+0xd2>
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13db <get_blocks+0x29b>
mov    -0x30(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x24(%rbp),%eax
jle    1365 <get_blocks+0x225>
cmpl   $0x0,-0x54(%rbp)
jne    1365 <get_blocks+0x225>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0x1,-0x54(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x24(%rbp),%eax
jle    1388 <get_blocks+0x248>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
cmp    -0xc(%rbp),%eax
jne    13c8 <get_blocks+0x288>
cmpl   $0x1,-0x54(%rbp)
jne    13c8 <get_blocks+0x288>
mov    -0x58(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movslq -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x5c(%rbp),%edx
sub    $0x1,%edx
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
jmp    13cd <get_blocks+0x28d>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    132e <get_blocks+0x1ee>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    14c9 <get_blocks+0x389>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1451 <get_blocks+0x311>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%rcx
movslq -0x5c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jl     143e <get_blocks+0x2fe>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movslq -0x5c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1451 <get_blocks+0x311>
jmp    1443 <get_blocks+0x303>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    13f5 <get_blocks+0x2b5>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jl     14b6 <get_blocks+0x376>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
mov    0x8(%rcx),%rcx
movslq -0x5c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     14a3 <get_blocks+0x363>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x5c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    14b6 <get_blocks+0x376>
jmp    14a8 <get_blocks+0x368>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    145a <get_blocks+0x31a>
jmp    14bb <get_blocks+0x37b>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    13e2 <get_blocks+0x2a2>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_blocks>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9d,0x10(%rsp)
mov    %r8d,0x8(%rsp)
mov    %ecx,%r13d
mov    %rdx,%r12
mov    %rdi,%r15
mov    0x90(%rsp),%r14d
mov    %rsi,0x18(%rsp)
lea    0x1(%rsi),%ebx
mov    %ebx,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%rbp
mov    %ebx,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
test   %r14d,%r14d
jle    11cf <get_blocks+0x8f>
mov    0x88(%rsp),%rsi
mov    0x80(%rsp),%rcx
mov    %r14d,%r8d
cmp    $0x1,%r14d
jne    14ca <get_blocks+0x38a>
xor    %edx,%edx
test   $0x1,%r8b
je     11cf <get_blocks+0x8f>
mov    (%rcx,%rdx,1),%cl
cmp    $0x4e,%cl
je     11c3 <get_blocks+0x83>
cmp    $0x2d,%cl
jne    11cf <get_blocks+0x8f>
movslq (%rsi,%rdx,4),%rcx
movl   $0x1,-0x4(%rax,%rcx,4)
mov    %rax,(%rsp)
mov    %r15,0x20(%rsp)
mov    %r13d,%r11d
mov    %r13d,0x14(%rsp)
test   %r13d,%r13d
jle    137d <get_blocks+0x23d>
mov    0x8(%rsp),%ecx
mov    %ecx,%eax
shr    $0x1f,%eax
add    %ecx,%eax
sar    %eax
mov    %rax,0x8(%rsp)
mov    %rbp,%rax
add    $0x30,%rax
mov    %rax,0x28(%rsp)
xor    %r14d,%r14d
mov    %r12,0x40(%rsp)
mov    %r11,0x38(%rsp)
mov    %rbp,0x30(%rsp)
mov    0x8(%rsp),%rbx
mov    0x18(%rsp),%r15
jmp    1247 <get_blocks+0x107>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r14
mov    0x38(%rsp),%r11
cmp    %r11,%r14
mov    0x40(%rsp),%r12
je     137d <get_blocks+0x23d>
mov    (%r12,%r14,4),%edi
mov    %edi,%esi
sub    %ebx,%esi
add    $0xffffffff,%edi
mov    %r15d,%edx
mov    (%rsp),%rbp
mov    %rbp,%rcx
call   1040 <extend_lower_part_of_window@plt>
mov    %eax,%r13d
test   %eax,%eax
mov    $0x0,%eax
cmovs  %eax,%r13d
mov    (%r12,%r14,4),%edi
lea    (%rdi,%rbx,1),%esi
add    $0x1,%edi
mov    %r15d,%edx
mov    %rbp,%rcx
mov    0x30(%rsp),%rbp
call   1060 <extend_upper_part_of_window@plt>
pcmpeqd %xmm4,%xmm4
cmp    %r15d,%eax
cmovg  %r15d,%eax
cmp    %eax,%r13d
jge    1230 <get_blocks+0xf0>
mov    %r13d,%ecx
mov    %eax,%eax
mov    %rax,%r10
sub    %rcx,%r10
cmp    $0x8,%r10
jb     1360 <get_blocks+0x220>
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdx
mov    %rdx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     1373 <get_blocks+0x233>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
mov    0x28(%rsp),%rdx
lea    (%rdx,%rcx,4),%rdx
xor    %esi,%esi
nop
movdqu -0x30(%rdx,%rsi,4),%xmm0
movdqu -0x20(%rdx,%rsi,4),%xmm1
movdqu -0x10(%rdx,%rsi,4),%xmm2
movdqu (%rdx,%rsi,4),%xmm3
psubd  %xmm4,%xmm0
psubd  %xmm4,%xmm1
movdqu %xmm0,-0x30(%rdx,%rsi,4)
movdqu %xmm1,-0x20(%rdx,%rsi,4)
psubd  %xmm4,%xmm2
psubd  %xmm4,%xmm3
movdqu %xmm2,-0x10(%rdx,%rsi,4)
movdqu %xmm3,(%rdx,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    12e0 <get_blocks+0x1a0>
test   $0x1,%r9b
je     1351 <get_blocks+0x211>
add    %rcx,%rsi
movdqu 0x0(%rbp,%rsi,4),%xmm0
movdqu 0x10(%rbp,%rsi,4),%xmm1
psubd  %xmm4,%xmm0
psubd  %xmm4,%xmm1
movdqu %xmm0,0x0(%rbp,%rsi,4)
movdqu %xmm1,0x10(%rbp,%rsi,4)
cmp    %r8,%r10
je     1230 <get_blocks+0xf0>
add    %r8,%rcx
nopl   (%rax)
addl   $0x1,0x0(%rbp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1360 <get_blocks+0x220>
jmp    1230 <get_blocks+0xf0>
xor    %esi,%esi
test   $0x1,%r9b
jne    132e <get_blocks+0x1ee>
jmp    1351 <get_blocks+0x211>
mov    0x18(%rsp),%rax
test   %eax,%eax
jle    14a4 <get_blocks+0x364>
mov    %rbp,%r15
mov    %eax,%r10d
lea    -0x1(%r10),%r8
xor    %edx,%edx
mov    $0x1,%r9d
xor    %edi,%edi
xor    %esi,%esi
xor    %r14d,%r14d
mov    0x10(%rsp),%r13d
mov    0x20(%rsp),%rbp
jmp    13d5 <get_blocks+0x295>
nop
mov    0x0(%rbp),%rax
movslq %r14d,%r14
mov    %edi,(%rax,%r14,4)
mov    0x8(%rbp),%rax
lea    -0x1(%rdx),%ecx
mov    %ecx,(%rax,%r14,4)
add    $0x1,%r14d
xor    %esi,%esi
add    $0x1,%rdx
cmp    %rdx,%r10
je     1419 <get_blocks+0x2d9>
mov    (%r15,%rdx,4),%eax
cmp    %r13d,%eax
setg   %cl
test   %esi,%esi
sete   %bl
test   %bl,%cl
mov    %esi,%ecx
cmovne %r9d,%ecx
mov    %edi,%esi
mov    %edx,%edi
cmove  %esi,%edi
cmp    %r13d,%eax
jle    1410 <get_blocks+0x2d0>
cmp    %rdx,%r8
jne    1402 <get_blocks+0x2c2>
cmp    $0x1,%ecx
je     13b0 <get_blocks+0x270>
mov    %ecx,%esi
jmp    13cc <get_blocks+0x28c>
cs nopw 0x0(%rax,%rax,1)
xor    %esi,%esi
cmp    $0x1,%ecx
jne    13cc <get_blocks+0x28c>
jmp    13b0 <get_blocks+0x270>
test   %r14d,%r14d
mov    0x14(%rsp),%r9d
jle    149b <get_blocks+0x35b>
mov    %r14d,%r8d
xor    %ecx,%ecx
jmp    1439 <get_blocks+0x2f9>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %r8,%rcx
je     149b <get_blocks+0x35b>
test   %r9d,%r9d
jle    1473 <get_blocks+0x333>
mov    0x0(%rbp),%rdx
mov    (%rdx,%rcx,4),%esi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
mov    (%r12,%rdi,4),%eax
cmp    %esi,%eax
jge    1470 <get_blocks+0x330>
add    $0x1,%rdi
cmp    %rdi,%r11
jne    1450 <get_blocks+0x310>
jmp    1473 <get_blocks+0x333>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %eax,(%rdx,%rcx,4)
mov    %r11,%rdx
cs nopw 0x0(%rax,%rax,1)
test   %edx,%edx
jle    1430 <get_blocks+0x2f0>
mov    -0x4(%r12,%rdx,4),%esi
mov    0x8(%rbp),%rdi
add    $0xffffffffffffffff,%rdx
cmp    (%rdi,%rcx,4),%esi
jg     1480 <get_blocks+0x340>
mov    %esi,(%rdi,%rcx,4)
jmp    1430 <get_blocks+0x2f0>
mov    (%rsp),%rdi
mov    %r15,%rbp
jmp    14ab <get_blocks+0x36b>
xor    %r14d,%r14d
mov    (%rsp),%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %r14d,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r8d,%edi
and    $0xfffffffe,%edi
xor    %edx,%edx
jmp    14fa <get_blocks+0x3ba>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq 0x4(%rsi,%rdx,4),%rbx
movl   $0x1,-0x4(%rax,%rbx,4)
add    $0x2,%rdx
cmp    %rdx,%rdi
je     11b0 <get_blocks+0x70>
movzbl (%rcx,%rdx,1),%ebx
cmp    $0x4e,%bl
je     1508 <get_blocks+0x3c8>
cmp    $0x2d,%bl
jne    1514 <get_blocks+0x3d4>
movslq (%rsi,%rdx,4),%rbx
movl   $0x1,-0x4(%rax,%rbx,4)
movzbl 0x1(%rcx,%rdx,1),%ebx
cmp    $0x4e,%bl
je     14e0 <get_blocks+0x3a0>
cmp    $0x2d,%bl
je     14e0 <get_blocks+0x3a0>
jmp    14ed <get_blocks+0x3ad>

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

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