#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 lower_bound(int *, int, int, int);
scalar_t__ malloc(int);
scalar_t__ realloc(int **, int);
void ksum_sub(int *nums, int numsSize, int start, int target, int k, int ***ret,
              int *retSize, int *index, int index_i, int index_sz) {
  if (k == 2) {
    int i, j = numsSize - 1, t;
    i = lower_bound(nums, start, numsSize, target - nums[j]);
    while (i < j) {
      if (nums[i] + nums[j] == target) {
        index[index_sz - 2] = i;
        index[index_sz - 1] = j;
        *ret = (int **)realloc(*ret, sizeof(int *) * (*retSize + 1));
        (*ret)[*retSize] = (int *)malloc(sizeof(int) * index_sz);
        for (t = 0; t < index_sz; ++t)
          (*ret)[*retSize][t] = nums[index[t]];
        ++*retSize;
        do {
          ++i;
        } while (i < j && nums[i - 1] == nums[i]);
        do {
          --j;
        } while (i < j && nums[j] == nums[j + 1]);
      } else if (nums[i] + nums[j] < target)
        do {
          ++i;
        } while (i < j && nums[i - 1] == nums[i]);
      else
        do {
          --j;
        } while (i < j && nums[j] == nums[j + 1]);
    }
  } else {
    int i = k, sum = 0;
    while (--i)
      sum += nums[numsSize - i];
    index[index_i] = lower_bound(nums, start, numsSize - k + 1, target - sum);
    if (index[index_i] == numsSize - k + 1)
      return;
    for (sum = 0, i = 0; i < k; ++i)
      sum += nums[index[index_i] + i];
    while (sum < target) {
      ksum_sub(nums, numsSize, index[index_i] + 1,
               target - nums[index[index_i]], k - 1, ret, retSize, index,
               index_i + 1, index_sz);
      do {
        sum = sum - nums[index[index_i]] + nums[index[index_i] + k];
        ++index[index_i];
      } while (index[index_i] <= numsSize - k &&
               nums[index[index_i] - 1] == nums[index[index_i]]);
    }
    if (sum == target) {
      *ret = (int **)realloc(*ret, sizeof(int *) * (*retSize + 1));
      (*ret)[*retSize] = (int *)malloc(sizeof(int) * index_sz);
      for (i = index_i + 1; i < index_sz; ++i)
        index[i] = index[i - 1] + 1;
      for (i = 0; i < index_sz; ++i)
        (*ret)[*retSize][i] = nums[index[i]];
      ++*retSize;
    }
  }
}


x86 assembly (clang, -O0):
<ksum_sub>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0x68,%rsp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
cmpl   $0x2,-0x20(%rbp)
jne    13f8 <ksum_sub+0x2b8>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x1c(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%r8
sub    (%rax,%r8,4),%ecx
call   1060 <lower_bound@plt>
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    13f3 <ksum_sub+0x2b3>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x30(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
cmp    -0x1c(%rbp),%eax
jne    132a <ksum_sub+0x1ea>
mov    -0x2c(%rbp),%edx
mov    0x18(%rbp),%rax
mov    0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%edx
mov    0x18(%rbp),%rax
mov    0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    (%rax),%rdi
mov    0x10(%rbp),%rax
mov    (%rax),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%esi
call   1050 <realloc@plt>
mov    %rax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
movslq 0x28(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    0x10(%rbp),%rcx
movslq (%rcx),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1289 <ksum_sub+0x149>
mov    -0x10(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    0x10(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1243 <ksum_sub+0x103>
mov    0x10(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x30(%rbp),%ecx
mov    %al,-0x3d(%rbp)
jge    12cf <ksum_sub+0x18f>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
sete   %al
mov    %al,-0x3d(%rbp)
mov    -0x3d(%rbp),%al
test   $0x1,%al
jne    1294 <ksum_sub+0x154>
jmp    12df <ksum_sub+0x19f>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x30(%rbp),%ecx
mov    %al,-0x3e(%rbp)
jge    131a <ksum_sub+0x1da>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
sete   %al
mov    %al,-0x3e(%rbp)
mov    -0x3e(%rbp),%al
test   $0x1,%al
jne    12df <ksum_sub+0x19f>
jmp    13ee <ksum_sub+0x2ae>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x30(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
cmp    -0x1c(%rbp),%eax
jge    1399 <ksum_sub+0x259>
jmp    134e <ksum_sub+0x20e>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x30(%rbp),%ecx
mov    %al,-0x3f(%rbp)
jge    1389 <ksum_sub+0x249>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
sete   %al
mov    %al,-0x3f(%rbp)
mov    -0x3f(%rbp),%al
test   $0x1,%al
jne    134e <ksum_sub+0x20e>
jmp    13e9 <ksum_sub+0x2a9>
jmp    139e <ksum_sub+0x25e>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x30(%rbp),%ecx
mov    %al,-0x40(%rbp)
jge    13d9 <ksum_sub+0x299>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
sete   %al
mov    %al,-0x40(%rbp)
mov    -0x40(%rbp),%al
test   $0x1,%al
jne    139e <ksum_sub+0x25e>
jmp    13e9 <ksum_sub+0x2a9>
jmp    13ee <ksum_sub+0x2ae>
jmp    11a0 <ksum_sub+0x60>
jmp    16ca <ksum_sub+0x58a>
mov    -0x20(%rbp),%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
cmp    $0x0,%eax
je     1432 <ksum_sub+0x2f2>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    1405 <ksum_sub+0x2c5>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edx
sub    -0x20(%rbp),%edx
add    $0x1,%edx
mov    -0x1c(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
call   1060 <lower_bound@plt>
mov    %eax,%edx
mov    0x18(%rbp),%rax
movslq 0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq 0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x14(%rbp),%ecx
sub    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    147b <ksum_sub+0x33b>
jmp    16ca <ksum_sub+0x58a>
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    14c1 <ksum_sub+0x381>
mov    -0x10(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq 0x20(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1489 <ksum_sub+0x349>
jmp    14c6 <ksum_sub+0x386>
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    15d5 <ksum_sub+0x495>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    0x18(%rbp),%rax
movslq 0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0x1c(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    0x18(%rbp),%r8
movslq 0x20(%rbp),%r9
movslq (%r8,%r9,4),%r8
sub    (%rax,%r8,4),%ecx
mov    -0x20(%rbp),%r8d
sub    $0x1,%r8d
mov    -0x28(%rbp),%r9
mov    0x10(%rbp),%rbx
mov    0x18(%rbp),%r11
mov    0x20(%rbp),%r10d
add    $0x1,%r10d
mov    0x28(%rbp),%eax
mov    %rbx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10d,0x10(%rsp)
mov    %eax,0x18(%rsp)
call   1030 <ksum_sub@plt>
mov    -0x3c(%rbp),%eax
mov    -0x10(%rbp),%rcx
mov    0x18(%rbp),%rdx
movslq 0x20(%rbp),%rsi
movslq (%rdx,%rsi,4),%rdx
sub    (%rcx,%rdx,4),%eax
mov    -0x10(%rbp),%rcx
mov    0x18(%rbp),%rdx
movslq 0x20(%rbp),%rsi
mov    (%rdx,%rsi,4),%edx
add    -0x20(%rbp),%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    0x18(%rbp),%rax
movslq 0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq 0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x14(%rbp),%edx
sub    -0x20(%rbp),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x41(%rbp)
jg     15c5 <ksum_sub+0x485>
mov    -0x10(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq 0x20(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    0x18(%rbp),%rdx
movslq 0x20(%rbp),%rsi
movslq (%rdx,%rsi,4),%rdx
cmp    (%rcx,%rdx,4),%eax
sete   %al
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%al
test   $0x1,%al
jne    1534 <ksum_sub+0x3f4>
jmp    14c6 <ksum_sub+0x386>
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    16c5 <ksum_sub+0x585>
mov    -0x28(%rbp),%rax
mov    (%rax),%rdi
mov    0x10(%rbp),%rax
mov    (%rax),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%esi
call   1050 <realloc@plt>
mov    %rax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
movslq 0x28(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    0x10(%rbp),%rcx
movslq (%rcx),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    166d <ksum_sub+0x52d>
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1635 <ksum_sub+0x4f5>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    16ba <ksum_sub+0x57a>
mov    -0x10(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x38(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    0x10(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1674 <ksum_sub+0x534>
mov    0x10(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    16ca <ksum_sub+0x58a>
add    $0x68,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<ksum_sub>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r9,0x8(%rsp)
mov    %esi,%r11d
mov    %rdi,%r15
cmp    $0x2,%r8d
mov    %ecx,0x4(%rsp)
jne    13be <ksum_sub+0x27e>
lea    -0x1(%r11),%r14d
movslq %r11d,%rax
sub    -0x4(%r15,%rax,4),%ecx
mov    %r15,%rdi
mov    %edx,%esi
mov    %r11d,%edx
call   1060 <lower_bound@plt>
mov    0x78(%rsp),%rdi
cmp    %r14d,%eax
jge    1a2a <ksum_sub+0x8ea>
mov    %eax,%ebp
mov    0x88(%rsp),%eax
mov    %rax,%rcx
add    $0xfffffffe,%eax
movslq %eax,%r8
lea    -0x1(%rcx),%eax
movslq %eax,%r9
lea    0x0(,%rcx,4),%eax
mov    %eax,0x28(%rsp)
mov    %ecx,%eax
mov    %rax,0x30(%rsp)
mov    %eax,%r10d
and    $0xfffffffe,%r10d
movslq %ebp,%r13
mov    (%r15,%r13,4),%eax
movslq %r14d,%r12
mov    (%r15,%r12,4),%ecx
lea    (%rcx,%rax,1),%edx
cmp    0x4(%rsp),%edx
jne    1270 <ksum_sub+0x130>
mov    %r10,0x18(%rsp)
mov    %r8,0x10(%rsp)
mov    %ebp,(%rdi,%r8,4)
mov    %r9,0x20(%rsp)
mov    %r14d,(%rdi,%r9,4)
mov    0x8(%rsp),%rax
mov    (%rax),%rdi
mov    0x70(%rsp),%rbx
mov    (%rbx),%eax
lea    0x8(,%rax,8),%esi
call   1050 <realloc@plt>
mov    0x8(%rsp),%rcx
mov    %rax,(%rcx)
mov    0x28(%rsp),%edi
call   1040 <malloc@plt>
mov    0x8(%rsp),%rsi
mov    (%rsi),%rdx
movslq (%rbx),%rcx
mov    %rax,(%rdx,%rcx,8)
mov    0x88(%rsp),%edx
test   %edx,%edx
jle    12d0 <ksum_sub+0x190>
mov    (%rsi),%rax
cmp    $0x1,%edx
mov    0x18(%rsp),%r10
jne    12e6 <ksum_sub+0x1a6>
xor    %edx,%edx
mov    0x78(%rsp),%rdi
mov    0x10(%rsp),%r8
mov    0x20(%rsp),%r9
jmp    1331 <ksum_sub+0x1f1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
jge    129e <ksum_sub+0x15e>
add    $0x1,%r13
cs nopw 0x0(%rax,%rax,1)
cmp    %r12,%r13
jge    1a2a <ksum_sub+0x8ea>
add    $0x1,%ebp
lea    0x1(%r13),%rcx
cmp    (%r15,%r13,4),%eax
mov    %rcx,%r13
je     1280 <ksum_sub+0x140>
jmp    13b0 <ksum_sub+0x270>
add    $0xffffffffffffffff,%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %r13,%r12
jle    1a2a <ksum_sub+0x8ea>
add    $0xffffffff,%r14d
lea    -0x1(%r12),%rax
cmp    %ecx,(%r15,%r12,4)
mov    %rax,%r12
je     12b0 <ksum_sub+0x170>
jmp    13b0 <ksum_sub+0x270>
mov    0x78(%rsp),%rdi
mov    0x10(%rsp),%r8
mov    0x20(%rsp),%r9
mov    0x18(%rsp),%r10
jmp    134c <ksum_sub+0x20c>
xor    %edx,%edx
mov    0x78(%rsp),%rdi
mov    0x10(%rsp),%r8
mov    0x20(%rsp),%r9
nopw   0x0(%rax,%rax,1)
movslq (%rdi,%rdx,4),%rsi
mov    (%r15,%rsi,4),%esi
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rcx
mov    %esi,(%rcx,%rdx,4)
movslq (%rbx),%rcx
movslq 0x4(%rdi,%rdx,4),%rsi
mov    (%r15,%rsi,4),%esi
mov    (%rax,%rcx,8),%rcx
mov    %esi,0x4(%rcx,%rdx,4)
add    $0x2,%rdx
mov    (%rbx),%ecx
cmp    %rdx,%r10
jne    1300 <ksum_sub+0x1c0>
testb  $0x1,0x30(%rsp)
je     134c <ksum_sub+0x20c>
movslq (%rdi,%rdx,4),%rsi
mov    (%r15,%rsi,4),%esi
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %esi,(%rax,%rdx,4)
mov    (%rbx),%ecx
add    $0x1,%ecx
mov    %ecx,(%rbx)
lea    0x1(%rbp),%eax
cmp    %eax,%r14d
cmovg  %r14d,%eax
add    $0x1,%r13
nop
cmp    %r12,%r13
jge    137c <ksum_sub+0x23c>
mov    -0x4(%r15,%r13,4),%ecx
lea    0x1(%r13),%rdx
add    $0x1,%ebp
cmp    (%r15,%r13,4),%ecx
mov    %rdx,%r13
je     1360 <ksum_sub+0x220>
jmp    137e <ksum_sub+0x23e>
mov    %eax,%ebp
movslq %ebp,%rax
add    $0xffffffffffffffff,%r12
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %rax,%r12
jle    1a2a <ksum_sub+0x8ea>
mov    (%r15,%r12,4),%ecx
lea    -0x1(%r12),%rdx
add    $0xffffffff,%r14d
cmp    0x4(%r15,%r12,4),%ecx
mov    %rdx,%r12
je     1390 <ksum_sub+0x250>
cmp    %r14d,%ebp
jl     11bf <ksum_sub+0x7f>
jmp    1a2a <ksum_sub+0x8ea>
mov    %r8d,%ebx
mov    0x80(%rsp),%r13d
mov    %r8d,%eax
add    $0xffffffff,%eax
mov    %eax,0x18(%rsp)
je     14b6 <ksum_sub+0x376>
cltq
movslq %r11d,%r9
lea    -0x2(%rbx),%r10d
xor    %ebp,%ebp
cmp    $0x7,%r10d
jb     14c0 <ksum_sub+0x380>
add    $0x1,%r10
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %rbx,%r14
test   %rdi,%rdi
je     156b <ksum_sub+0x42b>
mov    %rsi,%rbp
and    $0xfffffffffffffffe,%rbp
mov    %r9,%rdi
sub    %rax,%rdi
lea    (%r15,%rdi,4),%rdi
add    $0x30,%rdi
pxor   %xmm0,%xmm0
xor    %ebx,%ebx
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu -0x30(%rdi,%rbx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%rdi,%rbx,4),%xmm3
paddd  %xmm1,%xmm3
movdqu -0x10(%rdi,%rbx,4),%xmm0
paddd  %xmm2,%xmm0
movdqu (%rdi,%rbx,4),%xmm1
paddd  %xmm3,%xmm1
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1440 <ksum_sub+0x300>
test   $0x1,%sil
je     1492 <ksum_sub+0x352>
sub    %rax,%rbx
add    %r9,%rbx
movdqu (%r15,%rbx,4),%xmm2
paddd  %xmm2,%xmm0
movdqu 0x10(%r15,%rbx,4),%xmm2
paddd  %xmm2,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ebp
cmp    %r8,%r10
jne    14ba <ksum_sub+0x37a>
mov    %r14,%rbx
jmp    14db <ksum_sub+0x39b>
xor    %ebp,%ebp
jmp    14db <ksum_sub+0x39b>
sub    %r8,%rax
mov    %r14,%rbx
sub    %rax,%r9
lea    (%r15,%r9,4),%rdi
xor    %esi,%esi
nopl   0x0(%rax)
add    (%rdi,%rsi,4),%ebp
add    $0x1,%rsi
cmp    %esi,%eax
jne    14d0 <ksum_sub+0x390>
mov    %r11,0x28(%rsp)
mov    %r11d,%r12d
sub    %ebx,%r12d
lea    0x1(%r12),%r14d
sub    %ebp,%ecx
mov    %r15,%rdi
mov    %edx,%esi
mov    %r14d,%edx
call   1060 <lower_bound@plt>
movslq %r13d,%r11
mov    0x78(%rsp),%r10
mov    %eax,(%r10,%r11,4)
cmp    %r14d,%eax
je     1a2a <ksum_sub+0x8ea>
mov    %eax,%edx
test   %ebx,%ebx
jle    152f <ksum_sub+0x3ef>
movslq %edx,%r8
mov    %ebx,%eax
mov    %rbx,%r9
cmp    $0x8,%ebx
jae    153d <ksum_sub+0x3fd>
xor    %ecx,%ecx
xor    %ebp,%ebp
mov    0x4(%rsp),%esi
jmp    166c <ksum_sub+0x52c>
mov    %rbx,%r9
xor    %ebp,%ebp
mov    0x4(%rsp),%esi
jmp    167c <ksum_sub+0x53c>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%ebx
and    $0x3,%ebx
cmp    $0x18,%rsi
jae    1584 <ksum_sub+0x444>
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
jmp    1609 <ksum_sub+0x4c9>
pxor   %xmm0,%xmm0
xor    %ebx,%ebx
pxor   %xmm1,%xmm1
test   $0x1,%sil
jne    1477 <ksum_sub+0x337>
jmp    1492 <ksum_sub+0x352>
movabs $0x3ffffffffffffffe,%rsi
ff ff 3f
add    $0xfffffffffffffffe,%rsi
and    %rsi,%rdi
lea    (%r15,%r8,4),%rsi
add    $0x70,%rsi
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movdqu -0x70(%rsi,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x60(%rsi,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu -0x50(%rsi,%rbp,4),%xmm1
movdqu -0x40(%rsi,%rbp,4),%xmm3
movdqu -0x30(%rsi,%rbp,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu -0x20(%rsi,%rbp,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu -0x10(%rsi,%rbp,4),%xmm0
paddd  %xmm4,%xmm0
movdqu (%rsi,%rbp,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    15b0 <ksum_sub+0x470>
test   %rbx,%rbx
mov    0x4(%rsp),%esi
je     164d <ksum_sub+0x50d>
add    %r8,%rbp
lea    (%r15,%rbp,4),%rbp
add    $0x10,%rbp
shl    $0x5,%rbx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu -0x10(%rbp,%rdi,1),%xmm2
paddd  %xmm2,%xmm0
movdqu 0x0(%rbp,%rdi,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rdi
cmp    %rdi,%rbx
jne    1630 <ksum_sub+0x4f0>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ebp
cmp    %rax,%rcx
je     167c <ksum_sub+0x53c>
lea    (%r15,%r8,4),%rdi
add    (%rdi,%rcx,4),%ebp
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1670 <ksum_sub+0x530>
lea    (%r10,%r11,4),%rbx
cmp    %esi,%ebp
mov    %r11,0x10(%rsp)
jge    1727 <ksum_sub+0x5e7>
lea    0x1(%r13),%r14d
movslq %r9d,%rax
lea    (%r15,%rax,4),%r13
jmp    16b0 <ksum_sub+0x570>
nopw   0x0(%rax,%rax,1)
add    $0x1,%edx
mov    0x4(%rsp),%esi
cmp    %esi,%ebp
mov    0x78(%rsp),%r10
jge    1727 <ksum_sub+0x5e7>
movslq %edx,%rax
add    $0x1,%edx
mov    %esi,%ecx
sub    (%r15,%rax,4),%ecx
mov    %r15,%rdi
mov    0x28(%rsp),%rsi
mov    0x18(%rsp),%r8d
mov    0x8(%rsp),%r9
mov    0x88(%rsp),%eax
push   %rax
push   %r14
push   %r10
push   0x88(%rsp)
call   1030 <ksum_sub@plt>
add    $0x20,%rsp
movslq (%rbx),%rax
mov    (%r15,%rax,4),%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rax,%rdx
sub    %ecx,%ebp
add    0x0(%r13,%rax,4),%ebp
add    $0x1,%rax
mov    %eax,(%rbx)
cmp    %r12d,%edx
jge    16a0 <ksum_sub+0x560>
mov    (%r15,%rdx,4),%ecx
movslq %eax,%rsi
cmp    (%r15,%rsi,4),%ecx
je     1700 <ksum_sub+0x5c0>
jmp    16a0 <ksum_sub+0x560>
cmp    %esi,%ebp
mov    0x80(%rsp),%ebp
jne    1a2a <ksum_sub+0x8ea>
mov    0x8(%rsp),%r13
mov    0x0(%r13),%rdi
mov    0x70(%rsp),%r14
mov    (%r14),%eax
lea    0x8(,%rax,8),%esi
call   1050 <realloc@plt>
mov    %rax,0x0(%r13)
mov    0x88(%rsp),%r12d
lea    0x0(,%r12,4),%edi
call   1040 <malloc@plt>
mov    0x78(%rsp),%r11
mov    0x0(%r13),%rcx
movslq (%r14),%rdx
mov    %rax,(%rcx,%rdx,8)
lea    0x1(%rbp),%eax
cmp    %r12d,%eax
jge    19b0 <ksum_sub+0x870>
movslq %eax,%r10
lea    -0x2(%r12),%edx
mov    %edx,%r13d
sub    %ebp,%r13d
cmp    $0x7,%r13d
jb     18bd <ksum_sub+0x77d>
cmp    %ebp,%edx
jl     18bd <ksum_sub+0x77d>
lea    (%r11,%r10,4),%rsi
mov    %r12d,%edx
sub    %ebp,%edx
add    $0xfffffffe,%edx
mov    0x10(%rsp),%r14
add    %rdx,%r14
lea    (%r11,%r14,4),%rdi
add    $0x4,%rdi
cmp    %rdi,%rsi
jae    17dd <ksum_sub+0x69d>
add    %r10,%rdx
lea    (%r11,%rdx,4),%rdx
add    $0x4,%rdx
cmp    %rdx,%rbx
jb     18bd <ksum_sub+0x77d>
add    $0x1,%r13
mov    %r13,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdx
mov    %rdx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     1877 <ksum_sub+0x737>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%r11,%r10,4),%rbx
add    $0x30,%rbx
lea    0x8(%rbp),%edx
mov    %ebp,%ecx
xor    %edi,%edi
pcmpeqd %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
lea    (%rcx,%rdi,1),%eax
cltq
movdqu (%r11,%rax,4),%xmm1
movdqu 0x10(%r11,%rax,4),%xmm2
psubd  %xmm0,%xmm1
psubd  %xmm0,%xmm2
movdqu %xmm1,-0x30(%rbx,%rdi,4)
movdqu %xmm2,-0x20(%rbx,%rdi,4)
lea    (%rdx,%rdi,1),%eax
cltq
movdqu (%r11,%rax,4),%xmm1
movdqu 0x10(%r11,%rax,4),%xmm2
psubd  %xmm0,%xmm1
psubd  %xmm0,%xmm2
movdqu %xmm1,-0x10(%rbx,%rdi,4)
movdqu %xmm2,(%rbx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1820 <ksum_sub+0x6e0>
jmp    1879 <ksum_sub+0x739>
xor    %edi,%edi
test   $0x1,%r9b
je     18ae <ksum_sub+0x76e>
lea    (%rdi,%r10,1),%rax
add    %ebp,%edi
movslq %edi,%rdx
movdqu (%r11,%rdx,4),%xmm0
movdqu 0x10(%r11,%rdx,4),%xmm1
pcmpeqd %xmm2,%xmm2
psubd  %xmm2,%xmm0
psubd  %xmm2,%xmm1
movdqu %xmm0,(%r11,%rax,4)
movdqu %xmm1,0x10(%r11,%rax,4)
cmp    %r8,%r13
je     19b0 <ksum_sub+0x870>
add    %r8,%r10
add    %r8d,%ebp
mov    %r12d,%esi
sub    %r10d,%esi
mov    %r10d,%edx
not    %edx
add    %r12d,%edx
and    $0x3,%esi
je     190d <ksum_sub+0x7cd>
neg    %esi
xor    %edi,%edi
mov    %r10,%rcx
nopw   0x0(%rax,%rax,1)
movslq %ebp,%rax
mov    (%r11,%rax,4),%eax
add    $0x1,%eax
mov    %eax,(%r11,%rcx,4)
mov    %ecx,%ebp
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
cmp    %edi,%esi
jne    18e0 <ksum_sub+0x7a0>
not    %edi
add    %r10d,%edi
mov    %edi,%ebp
cmp    $0x3,%edx
jae    1919 <ksum_sub+0x7d9>
jmp    19b0 <ksum_sub+0x870>
mov    %r10,%rcx
cmp    $0x3,%edx
jb     19b0 <ksum_sub+0x870>
movabs $0x1fffffff8,%r8
mov    %r12d,%edx
mov    %rcx,%rax
shl    $0x20,%rax
movabs $0x100000000,%r9
movabs $0x400000000,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %ebp,%rbx
mov    (%r11,%rbx,4),%ebx
add    $0x1,%ebx
mov    %ebx,(%r11,%rcx,4)
mov    %rax,%rsi
sar    $0x1e,%rsi
mov    (%r11,%rsi,1),%esi
add    $0x1,%esi
mov    %esi,0x4(%r11,%rcx,4)
lea    (%rax,%r9,1),%rsi
sar    $0x1e,%rsi
mov    (%r11,%rsi,1),%esi
add    $0x1,%esi
mov    %esi,0x8(%r11,%rcx,4)
lea    (%r8,%rax,1),%rsi
add    $0x8,%rsi
sar    $0x1e,%rsi
mov    (%r11,%rsi,1),%esi
add    $0x1,%esi
mov    %esi,0xc(%r11,%rcx,4)
mov    %ecx,%ebp
lea    0x4(%rcx),%rsi
add    $0x3,%ebp
add    %rdi,%rax
mov    %rsi,%rcx
cmp    %esi,%edx
jne    1950 <ksum_sub+0x810>
test   %r12d,%r12d
mov    0x70(%rsp),%rbx
jle    1a27 <ksum_sub+0x8e7>
mov    0x8(%rsp),%rax
mov    (%rax),%rax
mov    %r12d,%ecx
cmp    $0x1,%r12d
jne    19cf <ksum_sub+0x88f>
xor    %edx,%edx
jmp    1a10 <ksum_sub+0x8d0>
mov    %ecx,%esi
and    $0xfffffffe,%esi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movslq (%r11,%rdx,4),%rdi
mov    (%r15,%rdi,4),%edi
movslq (%rbx),%rbp
mov    (%rax,%rbp,8),%rbp
mov    %edi,0x0(%rbp,%rdx,4)
movslq 0x4(%r11,%rdx,4),%rdi
mov    (%r15,%rdi,4),%edi
movslq (%rbx),%rbp
mov    (%rax,%rbp,8),%rbp
mov    %edi,0x4(%rbp,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%rsi
jne    19e0 <ksum_sub+0x8a0>
test   $0x1,%cl
je     1a27 <ksum_sub+0x8e7>
movslq (%r11,%rdx,4),%rcx
mov    (%r15,%rcx,4),%ecx
movslq (%rbx),%rsi
mov    (%rax,%rsi,8),%rax
mov    %ecx,(%rax,%rdx,4)
addl   $0x1,(%rbx)
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @ksum_sub(i32* %0, i32 %1, i32 %2, i32 %3, i32 %4, i32*** nocapture %5, i32* nocapture %6, i32* nocapture %7, i32 %8, i32 %9) {
%11 = icmp eq i32 %4, 2
br i1 %11, label %88, label %12
12: ; preds = %10
%13 = add i32 %4, -1
%14 = icmp eq i32 %13, 0
br i1 %14, label %247, label %15
15: ; preds = %12
%16 = sext i32 %13 to i64
%17 = sext i32 %1 to i64
%18 = add i32 %4, -2
%19 = zext i32 %18 to i64
%20 = add nuw nsw i64 %19, 1
%21 = icmp ult i32 %18, 7
br i1 %21, label %85, label %22
22: ; preds = %15
%23 = and i64 %20, 8589934584
%24 = sub nsw i64 %16, %23
%25 = add nsw i64 %23, -8
%26 = lshr exact i64 %25, 3
%27 = add nuw nsw i64 %26, 1
%28 = and i64 %27, 1
%29 = icmp eq i64 %25, 0
br i1 %29, label %61, label %30
30: ; preds = %22
%31 = and i64 %27, 4611686018427387902
br label %32
32: ; preds = %32, %30
%33 = phi i64 [ 0, %30 ], [ %58, %32 ]
%34 = phi <4 x i32> [ zeroinitializer, %30 ], [ %56, %32 ]
%35 = phi <4 x i32> [ zeroinitializer, %30 ], [ %57, %32 ]
%36 = phi i64 [ 0, %30 ], [ %59, %32 ]
%37 = sub i64 %33, %16
%38 = add i64 %37, %17
%39 = getelementptr inbounds i32, i32* %0, i64 %38
%40 = bitcast i32* %39 to <4 x i32>*
%41 = load <4 x i32>, <4 x i32>* %40
%42 = getelementptr inbounds i32, i32* %39, i64 4
%43 = bitcast i32* %42 to <4 x i32>*
%44 = load <4 x i32>, <4 x i32>* %43
%45 = add <4 x i32> %41, %34
%46 = add <4 x i32> %44, %35
%47 = or i64 %33, 8
%48 = sub i64 %47, %16
%49 = add i64 %48, %17
%50 = getelementptr inbounds i32, i32* %0, i64 %49
%51 = bitcast i32* %50 to <4 x i32>*
%52 = load <4 x i32>, <4 x i32>* %51
%53 = getelementptr inbounds i32, i32* %50, i64 4
%54 = bitcast i32* %53 to <4 x i32>*
%55 = load <4 x i32>, <4 x i32>* %54
%56 = add <4 x i32> %52, %45
%57 = add <4 x i32> %55, %46
%58 = add nuw i64 %33, 16
%59 = add i64 %36, 2
%60 = icmp eq i64 %59, %31
br i1 %60, label %61, label %32
61: ; preds = %32, %22
%62 = phi <4 x i32> [ undef, %22 ], [ %56, %32 ]
%63 = phi <4 x i32> [ undef, %22 ], [ %57, %32 ]
%64 = phi i64 [ 0, %22 ], [ %58, %32 ]
%65 = phi <4 x i32> [ zeroinitializer, %22 ], [ %56, %32 ]
%66 = phi <4 x i32> [ zeroinitializer, %22 ], [ %57, %32 ]
%67 = icmp eq i64 %28, 0
br i1 %67, label %79, label %68
68: ; preds = %61
%69 = sub i64 %64, %16
%70 = add i64 %69, %17
%71 = getelementptr inbounds i32, i32* %0, i64 %70
%72 = bitcast i32* %71 to <4 x i32>*
%73 = load <4 x i32>, <4 x i32>* %72
%74 = getelementptr inbounds i32, i32* %71, i64 4
%75 = bitcast i32* %74 to <4 x i32>*
%76 = load <4 x i32>, <4 x i32>* %75
%77 = add <4 x i32> %73, %65
%78 = add <4 x i32> %76, %66
br label %79
79: ; preds = %61, %68
%80 = phi <4 x i32> [ %62, %61 ], [ %77, %68 ]
%81 = phi <4 x i32> [ %63, %61 ], [ %78, %68 ]
%82 = add <4 x i32> %81, %80
%83 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %82)
%84 = icmp eq i64 %20, %23
br i1 %84, label %247, label %85
85: ; preds = %15, %79
%86 = phi i64 [ %16, %15 ], [ %24, %79 ]
%87 = phi i32 [ 0, %15 ], [ %83, %79 ]
br label %237
88: ; preds = %10
%89 = add nsw i32 %1, -1
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds i32, i32* %0, i64 %90
%92 = load i32, i32* %91
%93 = sub nsw i32 %3, %92
%94 = tail call i32 @lower_bound(i32* %0, i32 %2, i32 %1, i32 %93)
%95 = icmp slt i32 %94, %89
br i1 %95, label %96, label %629
96: ; preds = %88
%97 = add nsw i32 %9, -2
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds i32, i32* %7, i64 %98
%100 = add nsw i32 %9, -1
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds i32, i32* %7, i64 %101
%103 = shl i32 %9, 2
%104 = icmp sgt i32 %9, 0
%105 = zext i32 %9 to i64
%106 = and i64 %105, 1
%107 = icmp eq i32 %9, 1
%108 = and i64 %105, 4294967294
%109 = icmp eq i64 %106, 0
br label %110
110: ; preds = %96, %233
%111 = phi i32 [ %89, %96 ], [ %235, %233 ]
%112 = phi i32 [ %94, %96 ], [ %234, %233 ]
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i32, i32* %0, i64 %113
%115 = load i32, i32* %114
%116 = sext i32 %111 to i64
%117 = getelementptr inbounds i32, i32* %0, i64 %116
%118 = load i32, i32* %117
%119 = add nsw i32 %118, %115
%120 = icmp eq i32 %119, %3
br i1 %120, label %121, label %209
121: ; preds = %110
store i32 %112, i32* %99
store i32 %111, i32* %102
%122 = load i32**, i32*** %5
%123 = load i32, i32* %6
%124 = shl i32 %123, 3
%125 = add i32 %124, 8
%126 = tail call i64 @realloc(i32** %122, i32 %125)
%127 = inttoptr i64 %126 to i32**
store i32** %127, i32*** %5
%128 = tail call i64 @malloc(i32 %103)
%129 = inttoptr i64 %128 to i32*
%130 = load i32**, i32*** %5
%131 = load i32, i32* %6
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds i32*, i32** %130, i64 %132
store i32* %129, i32** %133
br i1 %104, label %134, label %179
134: ; preds = %121
%135 = load i32**, i32*** %5
br i1 %107, label %164, label %136
136: ; preds = %134, %136
%137 = phi i32 [ %161, %136 ], [ %131, %134 ]
%138 = phi i64 [ %160, %136 ], [ 0, %134 ]
%139 = phi i64 [ %162, %136 ], [ 0, %134 ]
%140 = getelementptr inbounds i32, i32* %7, i64 %138
%141 = load i32, i32* %140
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds i32, i32* %0, i64 %142
%144 = load i32, i32* %143
%145 = sext i32 %137 to i64
%146 = getelementptr inbounds i32*, i32** %135, i64 %145
%147 = load i32*, i32** %146
%148 = getelementptr inbounds i32, i32* %147, i64 %138
store i32 %144, i32* %148
%149 = or i64 %138, 1
%150 = load i32, i32* %6
%151 = getelementptr inbounds i32, i32* %7, i64 %149
%152 = load i32, i32* %151
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds i32, i32* %0, i64 %153
%155 = load i32, i32* %154
%156 = sext i32 %150 to i64
%157 = getelementptr inbounds i32*, i32** %135, i64 %156
%158 = load i32*, i32** %157
%159 = getelementptr inbounds i32, i32* %158, i64 %149
store i32 %155, i32* %159
%160 = add nuw nsw i64 %138, 2
%161 = load i32, i32* %6
%162 = add i64 %139, 2
%163 = icmp eq i64 %162, %108
br i1 %163, label %164, label %136
164: ; preds = %136, %134
%165 = phi i32 [ undef, %134 ], [ %161, %136 ]
%166 = phi i32 [ %131, %134 ], [ %161, %136 ]
%167 = phi i64 [ 0, %134 ], [ %160, %136 ]
br i1 %109, label %179, label %168
168: ; preds = %164
%169 = getelementptr inbounds i32, i32* %7, i64 %167
%170 = load i32, i32* %169
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds i32, i32* %0, i64 %171
%173 = load i32, i32* %172
%174 = sext i32 %166 to i64
%175 = getelementptr inbounds i32*, i32** %135, i64 %174
%176 = load i32*, i32** %175
%177 = getelementptr inbounds i32, i32* %176, i64 %167
store i32 %173, i32* %177
%178 = load i32, i32* %6
br label %179
179: ; preds = %168, %164, %121
%180 = phi i32 [ %131, %121 ], [ %165, %164 ], [ %178, %168 ]
%181 = add nsw i32 %180, 1
store i32 %181, i32* %6
%182 = add i32 %112, 1
%183 = call i32 @llvm.smax.i32(i32 %111, i32 %182)
br label %184
184: ; preds = %188, %179
%185 = phi i64 [ %186, %188 ], [ %113, %179 ]
%186 = add nsw i64 %185, 1
%187 = icmp slt i64 %186, %116
br i1 %187, label %188, label %196
188: ; preds = %184
%189 = getelementptr inbounds i32, i32* %0, i64 %185
%190 = load i32, i32* %189
%191 = getelementptr inbounds i32, i32* %0, i64 %186
%192 = load i32, i32* %191
%193 = icmp eq i32 %190, %192
br i1 %193, label %184, label %194
194: ; preds = %188
%195 = trunc i64 %186 to i32
br label %196
196: ; preds = %184, %194
%197 = phi i32 [ %195, %194 ], [ %183, %184 ]
%198 = sext i32 %197 to i64
br label %199
199: ; preds = %203, %196
%200 = phi i64 [ %201, %203 ], [ %116, %196 ]
%201 = add nsw i64 %200, -1
%202 = icmp sgt i64 %201, %198
br i1 %202, label %203, label %629
203: ; preds = %199
%204 = getelementptr inbounds i32, i32* %0, i64 %201
%205 = load i32, i32* %204
%206 = getelementptr inbounds i32, i32* %0, i64 %200
%207 = load i32, i32* %206
%208 = icmp eq i32 %205, %207
br i1 %208, label %199, label %227
209: ; preds = %110
%210 = icmp slt i32 %119, %3
br i1 %210, label %211, label %219
211: ; preds = %209, %215
%212 = phi i64 [ %213, %215 ], [ %113, %209 ]
%213 = add nsw i64 %212, 1
%214 = icmp slt i64 %213, %116
br i1 %214, label %215, label %629
215: ; preds = %211
%216 = getelementptr inbounds i32, i32* %0, i64 %213
%217 = load i32, i32* %216
%218 = icmp eq i32 %115, %217
br i1 %218, label %211, label %229
219: ; preds = %209, %223
%220 = phi i64 [ %221, %223 ], [ %116, %209 ]
%221 = add nsw i64 %220, -1
%222 = icmp sgt i64 %221, %113
br i1 %222, label %223, label %629
223: ; preds = %219
%224 = getelementptr inbounds i32, i32* %0, i64 %221
%225 = load i32, i32* %224
%226 = icmp eq i32 %225, %118
br i1 %226, label %219, label %231
227: ; preds = %203
%228 = trunc i64 %201 to i32
br label %233
229: ; preds = %215
%230 = trunc i64 %213 to i32
br label %233
231: ; preds = %223
%232 = trunc i64 %221 to i32
br label %233
233: ; preds = %231, %229, %227
%234 = phi i32 [ %197, %227 ], [ %230, %229 ], [ %112, %231 ]
%235 = phi i32 [ %228, %227 ], [ %111, %229 ], [ %232, %231 ]
%236 = icmp slt i32 %234, %235
br i1 %236, label %110, label %629
237: ; preds = %85, %237
%238 = phi i64 [ %244, %237 ], [ %86, %85 ]
%239 = phi i32 [ %243, %237 ], [ %87, %85 ]
%240 = sub nsw i64 %17, %238
%241 = getelementptr inbounds i32, i32* %0, i64 %240
%242 = load i32, i32* %241
%243 = add nsw i32 %242, %239
%244 = add nsw i64 %238, -1
%245 = trunc i64 %244 to i32
%246 = icmp eq i32 %245, 0
br i1 %246, label %247, label %237
247: ; preds = %237, %79, %12
%248 = phi i32 [ 0, %12 ], [ %83, %79 ], [ %243, %237 ]
%249 = sub nsw i32 %1, %4
%250 = add nsw i32 %249, 1
%251 = sub nsw i32 %3, %248
%252 = tail call i32 @lower_bound(i32* %0, i32 %2, i32 %250, i32 %251)
%253 = sext i32 %8 to i64
%254 = getelementptr inbounds i32, i32* %7, i64 %253
store i32 %252, i32* %254
%255 = icmp eq i32 %252, %250
br i1 %255, label %629, label %256
256: ; preds = %247
%257 = icmp sgt i32 %4, 0
br i1 %257, label %258, label %351
258: ; preds = %256
%259 = sext i32 %252 to i64
%260 = zext i32 %4 to i64
%261 = icmp ult i32 %4, 8
br i1 %261, label %348, label %262
262: ; preds = %258
%263 = and i64 %260, 4294967288
%264 = add nsw i64 %263, -8
%265 = lshr exact i64 %264, 3
%266 = add nuw nsw i64 %265, 1
%267 = and i64 %266, 3
%268 = icmp ult i64 %264, 24
br i1 %268, label %318, label %269
269: ; preds = %262
%270 = and i64 %266, 4611686018427387900
br label %271
271: ; preds = %271, %269
%272 = phi i64 [ 0, %269 ], [ %315, %271 ]
%273 = phi <4 x i32> [ zeroinitializer, %269 ], [ %313, %271 ]
%274 = phi <4 x i32> [ zeroinitializer, %269 ], [ %314, %271 ]
%275 = phi i64 [ 0, %269 ], [ %316, %271 ]
%276 = add nsw i64 %272, %259
%277 = getelementptr inbounds i32, i32* %0, i64 %276
%278 = bitcast i32* %277 to <4 x i32>*
%279 = load <4 x i32>, <4 x i32>* %278
%280 = getelementptr inbounds i32, i32* %277, i64 4
%281 = bitcast i32* %280 to <4 x i32>*
%282 = load <4 x i32>, <4 x i32>* %281
%283 = add <4 x i32> %279, %273
%284 = add <4 x i32> %282, %274
%285 = or i64 %272, 8
%286 = add nsw i64 %285, %259
%287 = getelementptr inbounds i32, i32* %0, i64 %286
%288 = bitcast i32* %287 to <4 x i32>*
%289 = load <4 x i32>, <4 x i32>* %288
%290 = getelementptr inbounds i32, i32* %287, i64 4
%291 = bitcast i32* %290 to <4 x i32>*
%292 = load <4 x i32>, <4 x i32>* %291
%293 = add <4 x i32> %289, %283
%294 = add <4 x i32> %292, %284
%295 = or i64 %272, 16
%296 = add nsw i64 %295, %259
%297 = getelementptr inbounds i32, i32* %0, i64 %296
%298 = bitcast i32* %297 to <4 x i32>*
%299 = load <4 x i32>, <4 x i32>* %298
%300 = getelementptr inbounds i32, i32* %297, i64 4
%301 = bitcast i32* %300 to <4 x i32>*
%302 = load <4 x i32>, <4 x i32>* %301
%303 = add <4 x i32> %299, %293
%304 = add <4 x i32> %302, %294
%305 = or i64 %272, 24
%306 = add nsw i64 %305, %259
%307 = getelementptr inbounds i32, i32* %0, i64 %306
%308 = bitcast i32* %307 to <4 x i32>*
%309 = load <4 x i32>, <4 x i32>* %308
%310 = getelementptr inbounds i32, i32* %307, i64 4
%311 = bitcast i32* %310 to <4 x i32>*
%312 = load <4 x i32>, <4 x i32>* %311
%313 = add <4 x i32> %309, %303
%314 = add <4 x i32> %312, %304
%315 = add nuw i64 %272, 32
%316 = add i64 %275, 4
%317 = icmp eq i64 %316, %270
br i1 %317, label %318, label %271
318: ; preds = %271, %262
%319 = phi <4 x i32> [ undef, %262 ], [ %313, %271 ]
%320 = phi <4 x i32> [ undef, %262 ], [ %314, %271 ]
%321 = phi i64 [ 0, %262 ], [ %315, %271 ]
%322 = phi <4 x i32> [ zeroinitializer, %262 ], [ %313, %271 ]
%323 = phi <4 x i32> [ zeroinitializer, %262 ], [ %314, %271 ]
%324 = icmp eq i64 %267, 0
br i1 %324, label %342, label %325
325: ; preds = %318, %325
%326 = phi i64 [ %339, %325 ], [ %321, %318 ]
%327 = phi <4 x i32> [ %337, %325 ], [ %322, %318 ]
%328 = phi <4 x i32> [ %338, %325 ], [ %323, %318 ]
%329 = phi i64 [ %340, %325 ], [ 0, %318 ]
%330 = add nsw i64 %326, %259
%331 = getelementptr inbounds i32, i32* %0, i64 %330
%332 = bitcast i32* %331 to <4 x i32>*
%333 = load <4 x i32>, <4 x i32>* %332
%334 = getelementptr inbounds i32, i32* %331, i64 4
%335 = bitcast i32* %334 to <4 x i32>*
%336 = load <4 x i32>, <4 x i32>* %335
%337 = add <4 x i32> %333, %327
%338 = add <4 x i32> %336, %328
%339 = add nuw i64 %326, 8
%340 = add i64 %329, 1
%341 = icmp eq i64 %340, %267
br i1 %341, label %342, label %325
342: ; preds = %325, %318
%343 = phi <4 x i32> [ %319, %318 ], [ %337, %325 ]
%344 = phi <4 x i32> [ %320, %318 ], [ %338, %325 ]
%345 = add <4 x i32> %344, %343
%346 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %345)
%347 = icmp eq i64 %263, %260
br i1 %347, label %351, label %348
348: ; preds = %258, %342
%349 = phi i64 [ 0, %258 ], [ %263, %342 ]
%350 = phi i32 [ 0, %258 ], [ %346, %342 ]
br label %356
351: ; preds = %356, %342, %256
%352 = phi i32 [ 0, %256 ], [ %346, %342 ], [ %362, %356 ]
%353 = icmp slt i32 %352, %3
br i1 %353, label %354, label %399
354: ; preds = %351
%355 = add nsw i32 %8, 1
br label %365
356: ; preds = %348, %356
%357 = phi i64 [ %363, %356 ], [ %349, %348 ]
%358 = phi i32 [ %362, %356 ], [ %350, %348 ]
%359 = add nsw i64 %357, %259
%360 = getelementptr inbounds i32, i32* %0, i64 %359
%361 = load i32, i32* %360
%362 = add nsw i32 %361, %358
%363 = add nuw nsw i64 %357, 1
%364 = icmp eq i64 %363, %260
br i1 %364, label %351, label %356
365: ; preds = %354, %397
%366 = phi i32 [ %252, %354 ], [ %387, %397 ]
%367 = phi i32 [ %352, %354 ], [ %386, %397 ]
%368 = add nsw i32 %366, 1
%369 = sext i32 %366 to i64
%370 = getelementptr inbounds i32, i32* %0, i64 %369
%371 = load i32, i32* %370
%372 = sub nsw i32 %3, %371
tail call void @ksum_sub(i32* %0, i32 %1, i32 %368, i32 %372, i32 %13, i32*** %5, i32* %6, i32* %7, i32 %355, i32 %9)
%373 = load i32, i32* %254
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds i32, i32* %0, i64 %374
%376 = load i32, i32* %375
br label %377
377: ; preds = %389, %365
%378 = phi i32 [ %376, %365 ], [ %392, %389 ]
%379 = phi i32 [ %373, %365 ], [ %387, %389 ]
%380 = phi i32 [ %367, %365 ], [ %386, %389 ]
%381 = sub nsw i32 %380, %378
%382 = add nsw i32 %379, %4
%383 = sext i32 %382 to i64
%384 = getelementptr inbounds i32, i32* %0, i64 %383
%385 = load i32, i32* %384
%386 = add nsw i32 %381, %385
%387 = add nsw i32 %379, 1
store i32 %387, i32* %254
%388 = icmp slt i32 %379, %249
br i1 %388, label %389, label %397
389: ; preds = %377
%390 = sext i32 %379 to i64
%391 = getelementptr inbounds i32, i32* %0, i64 %390
%392 = load i32, i32* %391
%393 = sext i32 %387 to i64
%394 = getelementptr inbounds i32, i32* %0, i64 %393
%395 = load i32, i32* %394
%396 = icmp eq i32 %392, %395
br i1 %396, label %377, label %397
397: ; preds = %377, %389
%398 = icmp slt i32 %386, %3
br i1 %398, label %365, label %399
399: ; preds = %397, %351
%400 = phi i32 [ %352, %351 ], [ %386, %397 ]
%401 = icmp eq i32 %400, %3
br i1 %401, label %402, label %629
402: ; preds = %399
%403 = load i32**, i32*** %5
%404 = load i32, i32* %6
%405 = shl i32 %404, 3
%406 = add i32 %405, 8
%407 = tail call i64 @realloc(i32** %403, i32 %406)
%408 = inttoptr i64 %407 to i32**
store i32** %408, i32*** %5
%409 = shl i32 %9, 2
%410 = tail call i64 @malloc(i32 %409)
%411 = inttoptr i64 %410 to i32*
%412 = load i32**, i32*** %5
%413 = load i32, i32* %6
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds i32*, i32** %412, i64 %414
store i32* %411, i32** %415
%416 = add i32 %8, 1
%417 = icmp slt i32 %416, %9
br i1 %417, label %418, label %543
418: ; preds = %402
%419 = sext i32 %416 to i64
%420 = add i32 %9, -2
%421 = sub i32 %420, %8
%422 = zext i32 %421 to i64
%423 = add nuw nsw i64 %422, 1
%424 = icmp ult i32 %421, 7
%425 = add i32 %9, -2
%426 = icmp slt i32 %425, %8
%427 = or i1 %424, %426
br i1 %427, label %515, label %428
428: ; preds = %418
%429 = getelementptr i32, i32* %7, i64 %419
%430 = add i32 %9, -2
%431 = sub i32 %430, %8
%432 = zext i32 %431 to i64
%433 = add nsw i64 %419, %432
%434 = add nsw i64 %433, 1
%435 = getelementptr i32, i32* %7, i64 %434
%436 = add nsw i64 %253, %432
%437 = add nsw i64 %436, 1
%438 = getelementptr i32, i32* %7, i64 %437
%439 = icmp ult i32* %429, %438
%440 = icmp ult i32* %254, %435
%441 = and i1 %439, %440
br i1 %441, label %515, label %442
442: ; preds = %428
%443 = and i64 %423, 8589934584
%444 = add nsw i64 %443, %419
%445 = trunc i64 %443 to i32
%446 = add i32 %445, %8
%447 = add nsw i64 %443, -8
%448 = lshr exact i64 %447, 3
%449 = add nuw nsw i64 %448, 1
%450 = and i64 %449, 1
%451 = icmp eq i64 %447, 0
br i1 %451, label %493, label %452
452: ; preds = %442
%453 = and i64 %449, 4611686018427387902
br label %454
454: ; preds = %454, %452
%455 = phi i64 [ 0, %452 ], [ %490, %454 ]
%456 = phi i64 [ 0, %452 ], [ %491, %454 ]
%457 = add i64 %455, %419
%458 = trunc i64 %455 to i32
%459 = add i32 %458, %8
%460 = sext i32 %459 to i64
%461 = getelementptr inbounds i32, i32* %7, i64 %460
%462 = bitcast i32* %461 to <4 x i32>*
%463 = load <4 x i32>, <4 x i32>* %462
%464 = getelementptr inbounds i32, i32* %461, i64 4
%465 = bitcast i32* %464 to <4 x i32>*
%466 = load <4 x i32>, <4 x i32>* %465
%467 = add nsw <4 x i32> %463, <i32 1, i32 1, i32 1, i32 1>
%468 = add nsw <4 x i32> %466, <i32 1, i32 1, i32 1, i32 1>
%469 = getelementptr inbounds i32, i32* %7, i64 %457
%470 = bitcast i32* %469 to <4 x i32>*
store <4 x i32> %467, <4 x i32>* %470
%471 = getelementptr inbounds i32, i32* %469, i64 4
%472 = bitcast i32* %471 to <4 x i32>*
store <4 x i32> %468, <4 x i32>* %472
%473 = or i64 %455, 8
%474 = add i64 %473, %419
%475 = trunc i64 %473 to i32
%476 = add i32 %475, %8
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds i32, i32* %7, i64 %477
%479 = bitcast i32* %478 to <4 x i32>*
%480 = load <4 x i32>, <4 x i32>* %479
%481 = getelementptr inbounds i32, i32* %478, i64 4
%482 = bitcast i32* %481 to <4 x i32>*
%483 = load <4 x i32>, <4 x i32>* %482
%484 = add nsw <4 x i32> %480, <i32 1, i32 1, i32 1, i32 1>
%485 = add nsw <4 x i32> %483, <i32 1, i32 1, i32 1, i32 1>
%486 = getelementptr inbounds i32, i32* %7, i64 %474
%487 = bitcast i32* %486 to <4 x i32>*
store <4 x i32> %484, <4 x i32>* %487
%488 = getelementptr inbounds i32, i32* %486, i64 4
%489 = bitcast i32* %488 to <4 x i32>*
store <4 x i32> %485, <4 x i32>* %489
%490 = add nuw i64 %455, 16
%491 = add i64 %456, 2
%492 = icmp eq i64 %491, %453
br i1 %492, label %493, label %454
493: ; preds = %454, %442
%494 = phi i64 [ 0, %442 ], [ %490, %454 ]
%495 = icmp eq i64 %450, 0
br i1 %495, label %513, label %496
496: ; preds = %493
%497 = add i64 %494, %419
%498 = trunc i64 %494 to i32
%499 = add i32 %498, %8
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds i32, i32* %7, i64 %500
%502 = bitcast i32* %501 to <4 x i32>*
%503 = load <4 x i32>, <4 x i32>* %502
%504 = getelementptr inbounds i32, i32* %501, i64 4
%505 = bitcast i32* %504 to <4 x i32>*
%506 = load <4 x i32>, <4 x i32>* %505
%507 = add nsw <4 x i32> %503, <i32 1, i32 1, i32 1, i32 1>
%508 = add nsw <4 x i32> %506, <i32 1, i32 1, i32 1, i32 1>
%509 = getelementptr inbounds i32, i32* %7, i64 %497
%510 = bitcast i32* %509 to <4 x i32>*
store <4 x i32> %507, <4 x i32>* %510
%511 = getelementptr inbounds i32, i32* %509, i64 4
%512 = bitcast i32* %511 to <4 x i32>*
store <4 x i32> %508, <4 x i32>* %512
br label %513
513: ; preds = %493, %496
%514 = icmp eq i64 %423, %443
br i1 %514, label %543, label %515
515: ; preds = %428, %418, %513
%516 = phi i64 [ %419, %428 ], [ %419, %418 ], [ %444, %513 ]
%517 = phi i32 [ %8, %428 ], [ %8, %418 ], [ %446, %513 ]
%518 = trunc i64 %516 to i32
%519 = sub i32 %9, %518
%520 = xor i32 %518, -1
%521 = add i32 %520, %9
%522 = and i32 %519, 3
%523 = icmp eq i32 %522, 0
br i1 %523, label %539, label %524
524: ; preds = %515, %524
%525 = phi i64 [ %533, %524 ], [ %516, %515 ]
%526 = phi i32 [ %534, %524 ], [ %517, %515 ]
%527 = phi i32 [ %535, %524 ], [ 0, %515 ]
%528 = sext i32 %526 to i64
%529 = getelementptr inbounds i32, i32* %7, i64 %528
%530 = load i32, i32* %529
%531 = add nsw i32 %530, 1
%532 = getelementptr inbounds i32, i32* %7, i64 %525
store i32 %531, i32* %532
%533 = add nsw i64 %525, 1
%534 = trunc i64 %525 to i32
%535 = add i32 %527, 1
%536 = icmp eq i32 %535, %522
br i1 %536, label %537, label %524
537: ; preds = %524
%538 = trunc i64 %525 to i32
br label %539
539: ; preds = %537, %515
%540 = phi i64 [ %516, %515 ], [ %533, %537 ]
%541 = phi i32 [ %517, %515 ], [ %538, %537 ]
%542 = icmp ult i32 %521, 3
br i1 %542, label %543, label %552
543: ; preds = %539, %552, %513, %402
%544 = icmp sgt i32 %9, 0
br i1 %544, label %545, label %626
545: ; preds = %543
%546 = load i32**, i32*** %5
%547 = zext i32 %9 to i64
%548 = and i64 %547, 1
%549 = icmp eq i32 %9, 1
br i1 %549, label %612, label %550
550: ; preds = %545
%551 = and i64 %547, 4294967294
br label %585
552: ; preds = %539, %552
%553 = phi i64 [ %581, %552 ], [ %540, %539 ]
%554 = phi i32 [ %582, %552 ], [ %541, %539 ]
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds i32, i32* %7, i64 %555
%557 = load i32, i32* %556
%558 = add nsw i32 %557, 1
%559 = getelementptr inbounds i32, i32* %7, i64 %553
store i32 %558, i32* %559
%560 = add nsw i64 %553, 1
%561 = shl i64 %553, 32
%562 = ashr exact i64 %561, 32
%563 = getelementptr inbounds i32, i32* %7, i64 %562
%564 = load i32, i32* %563
%565 = add nsw i32 %564, 1
%566 = getelementptr inbounds i32, i32* %7, i64 %560
store i32 %565, i32* %566
%567 = add nsw i64 %553, 2
%568 = shl i64 %560, 32
%569 = ashr exact i64 %568, 32
%570 = getelementptr inbounds i32, i32* %7, i64 %569
%571 = load i32, i32* %570
%572 = add nsw i32 %571, 1
%573 = getelementptr inbounds i32, i32* %7, i64 %567
store i32 %572, i32* %573
%574 = add nsw i64 %553, 3
%575 = shl i64 %567, 32
%576 = ashr exact i64 %575, 32
%577 = getelementptr inbounds i32, i32* %7, i64 %576
%578 = load i32, i32* %577
%579 = add nsw i32 %578, 1
%580 = getelementptr inbounds i32, i32* %7, i64 %574
store i32 %579, i32* %580
%581 = add nsw i64 %553, 4
%582 = trunc i64 %574 to i32
%583 = trunc i64 %581 to i32
%584 = icmp eq i32 %583, %9
br i1 %584, label %543, label %552
585: ; preds = %585, %550
%586 = phi i64 [ 0, %550 ], [ %609, %585 ]
%587 = phi i64 [ 0, %550 ], [ %610, %585 ]
%588 = getelementptr inbounds i32, i32* %7, i64 %586
%589 = load i32, i32* %588
%590 = sext i32 %589 to i64
%591 = getelementptr inbounds i32, i32* %0, i64 %590
%592 = load i32, i32* %591
%593 = load i32, i32* %6
%594 = sext i32 %593 to i64
%595 = getelementptr inbounds i32*, i32** %546, i64 %594
%596 = load i32*, i32** %595
%597 = getelementptr inbounds i32, i32* %596, i64 %586
store i32 %592, i32* %597
%598 = or i64 %586, 1
%599 = getelementptr inbounds i32, i32* %7, i64 %598
%600 = load i32, i32* %599
%601 = sext i32 %600 to i64
%602 = getelementptr inbounds i32, i32* %0, i64 %601
%603 = load i32, i32* %602
%604 = load i32, i32* %6
%605 = sext i32 %604 to i64
%606 = getelementptr inbounds i32*, i32** %546, i64 %605
%607 = load i32*, i32** %606
%608 = getelementptr inbounds i32, i32* %607, i64 %598
store i32 %603, i32* %608
%609 = add nuw nsw i64 %586, 2
%610 = add i64 %587, 2
%611 = icmp eq i64 %610, %551
br i1 %611, label %612, label %585
612: ; preds = %585, %545
%613 = phi i64 [ 0, %545 ], [ %609, %585 ]
%614 = icmp eq i64 %548, 0
br i1 %614, label %626, label %615
615: ; preds = %612
%616 = getelementptr inbounds i32, i32* %7, i64 %613
%617 = load i32, i32* %616
%618 = sext i32 %617 to i64
%619 = getelementptr inbounds i32, i32* %0, i64 %618
%620 = load i32, i32* %619
%621 = load i32, i32* %6
%622 = sext i32 %621 to i64
%623 = getelementptr inbounds i32*, i32** %546, i64 %622
%624 = load i32*, i32** %623
%625 = getelementptr inbounds i32, i32* %624, i64 %613
store i32 %620, i32* %625
br label %626
626: ; preds = %615, %612, %543
%627 = load i32, i32* %6
%628 = add nsw i32 %627, 1
store i32 %628, i32* %6
br label %629
629: ; preds = %233, %219, %211, %199, %88, %247, %626, %399
ret void
}