void simple_adaptive_threshold(const unsigned char *source, int source_stride,
                               unsigned char *dest, int width, int height,
                               int tile_size) {
  int x_step = tile_size;
  int y_step = tile_size;
  int y, x;
  for (y = 0; y < height; y += y_step) {
    for (x = 0; x < width; x += x_step) {
      int xxmax, yymax, sum, count;
      int yy, xx;
      int mean;
      xxmax = x + x_step;
      if (xxmax > width)
        xxmax = width;
      yymax = y + y_step;
      if (yymax > height)
        yymax = height;
      sum = 0;
      count = 0;
      for (yy = y; yy < yymax; ++yy) {
        for (xx = x; xx < xxmax; ++xx) {
          sum += source[(yy * width + xx) * source_stride];
          ++count;
        }
      }
      mean = sum / count;
      for (yy = y; yy < yymax; ++yy) {
        for (xx = x; xx < xxmax; ++xx) {
          if (source[(yy * width + xx) * source_stride] > mean) {
            dest[(yy * width + xx)] = 255;
          } else {
            dest[(yy * width + xx)] = 0;
          }
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<simple_adaptive_threshold>:
push   %rbp
mov    %rsp,%rbp
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    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12c8 <simple_adaptive_threshold+0x1c8>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12b5 <simple_adaptive_threshold+0x1b5>
mov    -0x34(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jle    1167 <simple_adaptive_threshold+0x67>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x30(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jle    1182 <simple_adaptive_threshold+0x82>
mov    -0x20(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    11fd <simple_adaptive_threshold+0xfd>
mov    -0x34(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    11ea <simple_adaptive_threshold+0xea>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x4c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    11a8 <simple_adaptive_threshold+0xa8>
jmp    11ef <simple_adaptive_threshold+0xef>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1196 <simple_adaptive_threshold+0x96>
mov    -0x40(%rbp),%eax
cltd
idivl  -0x44(%rbp)
mov    %eax,-0x50(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    12a2 <simple_adaptive_threshold+0x1a2>
mov    -0x34(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    128f <simple_adaptive_threshold+0x18f>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x4c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cmp    -0x50(%rbp),%eax
jle    1267 <simple_adaptive_threshold+0x167>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movb   $0xff,(%rax,%rcx,1)
jmp    127c <simple_adaptive_threshold+0x17c>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    1281 <simple_adaptive_threshold+0x181>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    121f <simple_adaptive_threshold+0x11f>
jmp    1294 <simple_adaptive_threshold+0x194>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    120d <simple_adaptive_threshold+0x10d>
jmp    12a7 <simple_adaptive_threshold+0x1a7>
mov    -0x28(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1140 <simple_adaptive_threshold+0x40>
jmp    12ba <simple_adaptive_threshold+0x1ba>
mov    -0x2c(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    112d <simple_adaptive_threshold+0x2d>
pop    %rbp
ret

x86 assembly (clang, -O2):
<simple_adaptive_threshold>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %rdx,-0x28(%rsp)
mov    %esi,-0x68(%rsp)
mov    %rdi,-0x70(%rsp)
mov    %r8d,-0x58(%rsp)
test   %r8d,%r8d
jle    194f <simple_adaptive_threshold+0x84f>
movslq %r9d,%rsi
movslq -0x68(%rsp),%r15
movslq %ecx,%r14
mov    %rsi,%rax
imul   %r14,%rax
lea    0x0(,%r15,8),%rdx
mov    %rdx,0xb0(%rsp)
mov    -0x70(%rsp),%rdx
lea    (%rdx,%r15,8),%rdi
add    $0x4,%rdi
mov    %rdi,0x18(%rsp)
mov    %rax,0x20(%rsp)
imul   %r15,%rax
mov    %rax,0x90(%rsp)
mov    %rsi,%rax
imul   %r15,%rax
mov    %rax,0xc0(%rsp)
mov    %r14,%rax
imul   %r15,%rax
mov    %rax,0x78(%rsp)
mov    %r15,%rax
shl    $0x4,%rax
mov    %rax,0x98(%rsp)
lea    0x4(%rdx),%rax
mov    %rax,0x10(%rsp)
mov    -0x28(%rsp),%rax
lea    0x10(%rax),%rdi
mov    %rdi,0x8(%rsp)
add    $0x10,%rdx
mov    %rdx,(%rsp)
mov    %r15,%rdx
shl    $0x5,%rdx
mov    %rdx,0xa0(%rsp)
xor    %edx,%edx
mov    %rdx,-0x50(%rsp)
pxor   %xmm10,%xmm10
pcmpeqd %xmm8,%xmm8
movdqa 0xe1c(%rip),%xmm9
mov    %rax,-0x38(%rsp)
xor    %eax,%eax
mov    %rax,-0x8(%rsp)
xor    %eax,%eax
mov    %rax,-0x78(%rsp)
mov    %r9,0xc8(%rsp)
mov    %ecx,-0x10(%rsp)
mov    %rsi,0x48(%rsp)
mov    %r14,0x80(%rsp)
jmp    1267 <simple_adaptive_threshold+0x167>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x78(%rsp),%rdi
add    %rsi,%rdi
addq   $0x1,-0x8(%rsp)
mov    0x90(%rsp),%rdx
add    %rdx,0x18(%rsp)
add    %rdx,0x10(%rsp)
mov    0x20(%rsp),%rax
add    %rax,-0x50(%rsp)
add    %rax,0x8(%rsp)
add    %rdx,(%rsp)
add    %rax,-0x38(%rsp)
mov    %rdi,-0x78(%rsp)
cmp    -0x58(%rsp),%edi
jge    194f <simple_adaptive_threshold+0x84f>
test   %ecx,%ecx
jle    1220 <simple_adaptive_threshold+0x120>
mov    0x20(%rsp),%rax
imul   -0x8(%rsp),%rax
mov    %rax,0xa8(%rsp)
mov    -0x78(%rsp),%rax
lea    (%rax,%r9,1),%edx
mov    -0x58(%rsp),%eax
cmp    %eax,%edx
cmovg  %eax,%edx
mov    %edx,-0x54(%rsp)
movslq %edx,%rax
mov    %rax,0x88(%rsp)
mov    $0x1,%edx
movq   $0xfffffffffffffff8,0x68(%rsp)
ff ff
mov    -0x50(%rsp),%rax
mov    %rax,0x40(%rsp)
mov    -0x38(%rsp),%rax
mov    %rax,0x38(%rsp)
mov    (%rsp),%rax
mov    %rax,0x30(%rsp)
mov    0x8(%rsp),%rax
mov    %rax,0x28(%rsp)
xor    %eax,%eax
mov    %rax,0x60(%rsp)
mov    %r9d,%edi
mov    0x10(%rsp),%rax
mov    %rax,0x58(%rsp)
mov    0x18(%rsp),%rax
mov    %rax,0x50(%rsp)
xor    %ebp,%ebp
xor    %ebx,%ebx
jmp    136c <simple_adaptive_threshold+0x26c>
nopl   0x0(%rax,%rax,1)
mov    0x70(%rsp),%rbp
add    $0x1,%rbp
mov    0xc0(%rsp),%rax
add    %rax,0x50(%rsp)
add    %rax,0x58(%rsp)
mov    0x48(%rsp),%rsi
mov    0xe0(%rsp),%rdx
add    %rsi,%rdx
mov    0xc8(%rsp),%r9
mov    -0xc(%rsp),%edi
add    %r9d,%edi
sub    %rsi,0x68(%rsp)
sub    %rsi,0x60(%rsp)
add    %rsi,0x28(%rsp)
add    %rax,0x30(%rsp)
add    %rsi,0x38(%rsp)
add    %rsi,0x40(%rsp)
mov    -0x10(%rsp),%ecx
mov    0xd8(%rsp),%rbx
cmp    %ecx,%ebx
jge    1220 <simple_adaptive_threshold+0x120>
cmp    %edi,%ecx
mov    %edi,-0xc(%rsp)
mov    %edi,%eax
cmovl  %ecx,%eax
movslq %eax,%rdi
cmp    %rdi,%rdx
mov    %rdx,0xe0(%rsp)
cmovg  %rdx,%rdi
lea    0x1(%rbx),%rax
mov    %rbp,0x70(%rsp)
mov    %ebp,%edx
imul   %r9d,%edx
add    %r9d,%edx
cmp    %edx,%ecx
cmovl  %ecx,%edx
movslq %edx,%rdx
cmp    %rdx,%rax
cmovg  %rax,%rdx
mov    %rbx,%rax
mov    %rbx,-0x80(%rsp)
lea    (%rbx,%rsi,1),%rax
cmp    %ecx,%eax
mov    %rax,0xd8(%rsp)
cmovg  %ecx,%eax
mov    %eax,-0x64(%rsp)
mov    -0x54(%rsp),%eax
cmp    -0x78(%rsp),%eax
jle    1300 <simple_adaptive_threshold+0x200>
mov    0x60(%rsp),%rax
add    %rdi,%rax
mov    %rax,%rcx
and    $0xfffffffffffffff8,%rcx
mov    %rcx,0xd0(%rsp)
and    $0xffffffffffffffe0,%rax
mov    %rax,0xb8(%rsp)
add    0x68(%rsp),%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
and    $0xfffffffffffffffe,%rdi
mov    %rdi,-0x30(%rsp)
mov    0x70(%rsp),%rax
imul   0x48(%rsp),%rax
mov    %rdx,%rsi
sub    %rax,%rsi
neg    %rax
add    %rdx,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x40(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %rax,-0x48(%rsp)
mov    0xa8(%rsp),%rax
mov    -0x80(%rsp),%rcx
lea    (%rax,%rcx,1),%rdi
mov    %rdi,0xe8(%rsp)
add    %rax,%rdx
mov    %rdx,0xf0(%rsp)
cmpl   $0x1,-0x68(%rsp)
sete   %al
movslq -0x64(%rsp),%r11
cmp    $0x8,%rsi
setae  %r13b
and    %al,%r13b
mov    %rsi,%rax
mov    %rsi,-0x60(%rsp)
and    $0xfffffffffffffff8,%rsi
mov    %rsi,-0x18(%rsp)
lea    (%rcx,%rsi,1),%rax
mov    %rax,-0x20(%rsp)
xor    %esi,%esi
mov    -0x50(%rsp),%r12
mov    0x58(%rsp),%rdi
mov    0x50(%rsp),%rdx
mov    -0x78(%rsp),%r10
xor    %eax,%eax
mov    0x78(%rsp),%r8
mov    0x98(%rsp),%r9
jmp    14db <simple_adaptive_threshold+0x3db>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10
add    %r8,%rdx
add    %r8,%rdi
add    %r14,%r12
cmp    0x88(%rsp),%r10
jge    1660 <simple_adaptive_threshold+0x560>
mov    -0x64(%rsp),%ecx
cmp    -0x80(%rsp),%ecx
jle    14c0 <simple_adaptive_threshold+0x3c0>
test   %r13b,%r13b
je     1510 <simple_adaptive_threshold+0x410>
movd   %esi,%xmm3
movd   %eax,%xmm4
cmpq   $0x8,-0x40(%rsp)
jae    151a <simple_adaptive_threshold+0x41a>
pxor   %xmm5,%xmm5
xor    %eax,%eax
pxor   %xmm6,%xmm6
jmp    1595 <simple_adaptive_threshold+0x495>
nopl   0x0(%rax)
mov    -0x80(%rsp),%rcx
jmp    162e <simple_adaptive_threshold+0x52e>
pxor   %xmm5,%xmm5
mov    -0x30(%rsp),%rsi
xor    %ebp,%ebp
xor    %eax,%eax
pxor   %xmm6,%xmm6
nopl   0x0(%rax,%rax,1)
movd   -0x4(%rdi,%rbp,1),%xmm1
movd   (%rdi,%rbp,1),%xmm7
punpcklbw %xmm10,%xmm1
punpcklwd %xmm10,%xmm1
paddd  %xmm4,%xmm1
punpcklbw %xmm10,%xmm7
punpcklwd %xmm10,%xmm7
paddd  %xmm6,%xmm7
movd   -0x4(%rdx,%rbp,1),%xmm4
movd   (%rdx,%rbp,1),%xmm6
punpcklbw %xmm10,%xmm4
punpcklwd %xmm10,%xmm4
paddd  %xmm1,%xmm4
punpcklbw %xmm10,%xmm6
punpcklwd %xmm10,%xmm6
paddd  %xmm7,%xmm6
paddd  %xmm9,%xmm3
paddd  %xmm9,%xmm5
add    $0x10,%rax
add    %r9,%rbp
add    $0xfffffffffffffffe,%rsi
jne    1530 <simple_adaptive_threshold+0x430>
testb  $0x1,-0x48(%rsp)
je     15e5 <simple_adaptive_threshold+0x4e5>
mov    %r10,%rcx
imul   %r14,%rcx
add    -0x80(%rsp),%rax
add    %rcx,%rax
imul   %r15,%rax
mov    -0x70(%rsp),%rcx
movd   (%rcx,%rax,1),%xmm1
movd   0x4(%rcx,%rax,1),%xmm7
punpcklbw %xmm10,%xmm1
punpcklwd %xmm10,%xmm1
paddd  %xmm1,%xmm4
punpcklbw %xmm10,%xmm7
punpcklwd %xmm10,%xmm7
paddd  %xmm7,%xmm6
psubd  %xmm8,%xmm3
psubd  %xmm8,%xmm5
paddd  %xmm5,%xmm3
paddd  %xmm6,%xmm4
pshufd $0xee,%xmm4,%xmm1
paddd  %xmm4,%xmm1
pshufd $0x55,%xmm1,%xmm4
paddd  %xmm1,%xmm4
movd   %xmm4,%eax
pshufd $0xee,%xmm3,%xmm1
paddd  %xmm3,%xmm1
pshufd $0x55,%xmm1,%xmm3
paddd  %xmm1,%xmm3
movd   %xmm3,%esi
mov    -0x20(%rsp),%rcx
mov    -0x18(%rsp),%rbx
cmp    %rbx,-0x60(%rsp)
je     14c0 <simple_adaptive_threshold+0x3c0>
lea    (%rcx,%r12,1),%rbp
imul   %r15,%rbp
add    -0x70(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movzbl 0x0(%rbp),%ebx
add    %ebx,%eax
add    $0x1,%esi
add    $0x1,%rcx
add    %r15,%rbp
cmp    %r11,%rcx
jl     1640 <simple_adaptive_threshold+0x540>
jmp    14c0 <simple_adaptive_threshold+0x3c0>
nopw   0x0(%rax,%rax,1)
cltd
idiv   %esi
mov    -0x54(%rsp),%ecx
cmp    -0x78(%rsp),%ecx
jle    1300 <simple_adaptive_threshold+0x200>
cmpl   $0x1,-0x68(%rsp)
sete   %cl
mov    -0x60(%rsp),%rdx
cmp    $0x8,%rdx
setae  %bpl
and    %cl,%bpl
and    $0xffffffffffffffe0,%rdx
movd   %eax,%xmm1
pshufd $0x0,%xmm1,%xmm11
mov    -0x80(%rsp),%rcx
mov    %rdx,-0x48(%rsp)
add    %rcx,%rdx
mov    %rdx,-0x30(%rsp)
mov    -0x18(%rsp),%rdx
add    %rdx,%rcx
mov    %rcx,-0x20(%rsp)
mov    -0x50(%rsp),%rdi
mov    -0x38(%rsp),%r10
mov    0x40(%rsp),%rcx
mov    %rcx,-0x40(%rsp)
mov    0x38(%rsp),%r13
mov    0x30(%rsp),%r8
mov    0x28(%rsp),%rsi
xor    %r12d,%r12d
mov    -0x78(%rsp),%r9
jmp    1724 <simple_adaptive_threshold+0x624>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r9
add    $0x1,%r12
mov    0x80(%rsp),%r14
add    %r14,%rsi
add    0x78(%rsp),%r8
add    %r14,%r13
add    %r14,-0x40(%rsp)
add    %r14,%r10
add    %r14,%rdi
cmp    0x88(%rsp),%r9
jge    1300 <simple_adaptive_threshold+0x200>
mov    -0x64(%rsp),%ecx
cmp    -0x80(%rsp),%ecx
jle    16f0 <simple_adaptive_threshold+0x5f0>
mov    -0x80(%rsp),%rdx
test   %bpl,%bpl
je     1920 <simple_adaptive_threshold+0x820>
mov    %r12,%rcx
imul   0x80(%rsp),%rcx
mov    0xe8(%rsp),%rdx
lea    (%rdx,%rcx,1),%r14
mov    -0x28(%rsp),%rdx
add    %r14,%rdx
add    0xf0(%rsp),%rcx
mov    -0x70(%rsp),%rbx
add    %rcx,%rbx
cmp    %rbx,%rdx
jae    1789 <simple_adaptive_threshold+0x689>
add    -0x28(%rsp),%rcx
add    -0x70(%rsp),%r14
mov    -0x80(%rsp),%rdx
cmp    %rcx,%r14
jb     1920 <simple_adaptive_threshold+0x820>
cmpq   $0x20,-0x60(%rsp)
jae    1798 <simple_adaptive_threshold+0x698>
xor    %ecx,%ecx
jmp    188d <simple_adaptive_threshold+0x78d>
mov    %r8,%rdx
xor    %ecx,%ecx
mov    0xa0(%rsp),%r14
mov    0xb8(%rsp),%rbx
nopl   (%rax)
movdqu -0x10(%rdx),%xmm4
movdqu (%rdx),%xmm5
movdqa %xmm4,%xmm1
punpcklbw %xmm10,%xmm1
movdqa %xmm1,%xmm2
punpcklwd %xmm10,%xmm2
punpckhwd %xmm10,%xmm1
punpckhbw %xmm10,%xmm4
movdqa %xmm4,%xmm0
punpcklwd %xmm10,%xmm0
punpckhwd %xmm10,%xmm4
movdqa %xmm5,%xmm7
punpcklbw %xmm10,%xmm7
movdqa %xmm7,%xmm6
punpcklwd %xmm10,%xmm6
punpckhwd %xmm10,%xmm7
punpckhbw %xmm10,%xmm5
movdqa %xmm5,%xmm3
punpcklwd %xmm10,%xmm3
punpckhwd %xmm10,%xmm5
pcmpgtd %xmm11,%xmm4
pcmpgtd %xmm11,%xmm0
packssdw %xmm4,%xmm0
pcmpgtd %xmm11,%xmm1
pcmpgtd %xmm11,%xmm2
packssdw %xmm1,%xmm2
packsswb %xmm0,%xmm2
pcmpgtd %xmm11,%xmm5
pcmpgtd %xmm11,%xmm3
packssdw %xmm5,%xmm3
pcmpgtd %xmm11,%xmm7
pcmpgtd %xmm11,%xmm6
packssdw %xmm7,%xmm6
packsswb %xmm3,%xmm6
movdqu %xmm2,-0x10(%rsi,%rcx,1)
movdqu %xmm6,(%rsi,%rcx,1)
add    $0x20,%rcx
add    %r14,%rdx
cmp    %rcx,%rbx
jne    17b0 <simple_adaptive_threshold+0x6b0>
mov    -0x48(%rsp),%rcx
cmp    %rcx,-0x60(%rsp)
je     16f0 <simple_adaptive_threshold+0x5f0>
mov    -0x48(%rsp),%rcx
mov    -0x30(%rsp),%rdx
testb  $0x18,-0x60(%rsp)
je     1920 <simple_adaptive_threshold+0x820>
mov    %ebp,%r14d
mov    -0x40(%rsp),%rdx
add    %rcx,%rdx
imul   %r15,%rdx
add    -0x70(%rsp),%rdx
mov    0xb0(%rsp),%rbx
mov    0xd0(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   (%rdx),%xmm0
punpcklbw %xmm10,%xmm0
movdqa %xmm0,%xmm1
punpcklwd %xmm10,%xmm1
punpckhwd %xmm10,%xmm0
pcmpgtd %xmm11,%xmm0
pcmpgtd %xmm11,%xmm1
packssdw %xmm0,%xmm1
packsswb %xmm1,%xmm1
movq   %xmm1,0x0(%r13,%rcx,1)
add    $0x8,%rcx
add    %rbx,%rdx
cmp    %rcx,%rbp
jne    18c0 <simple_adaptive_threshold+0x7c0>
mov    -0x20(%rsp),%rdx
mov    -0x18(%rsp),%rcx
cmp    %rcx,-0x60(%rsp)
mov    %r14d,%ebp
je     16f0 <simple_adaptive_threshold+0x5f0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rdx,%rdi,1),%rcx
imul   %r15,%rcx
add    -0x70(%rsp),%rcx
nopl   (%rax)
movzbl (%rcx),%ebx
cmp    %ebx,%eax
setl   %bl
neg    %bl
mov    %bl,(%r10,%rdx,1)
add    $0x1,%rdx
add    %r15,%rcx
cmp    %r11,%rdx
jl     1930 <simple_adaptive_threshold+0x830>
jmp    16f0 <simple_adaptive_threshold+0x5f0>
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @simple_adaptive_threshold(i8* %0, i32 %1, i8* %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i8*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
store i8* %0, i8** %7
store i32 %1, i32* %8
store i8* %2, i8** %9
store i32 %3, i32* %10
store i32 %4, i32* %11
store i32 %5, i32* %12
%24 = load i32, i32* %12
store i32 %24, i32* %13
%25 = load i32, i32* %12
store i32 %25, i32* %14
store i32 0, i32* %15
br label %26
26: ; preds = %151, %6
%27 = load i32, i32* %15
%28 = load i32, i32* %11
%29 = icmp slt i32 %27, %28
br i1 %29, label %30, label %155
30: ; preds = %26
store i32 0, i32* %16
br label %31
31: ; preds = %146, %30
%32 = load i32, i32* %16
%33 = load i32, i32* %10
%34 = icmp slt i32 %32, %33
br i1 %34, label %35, label %150
35: ; preds = %31
%36 = load i32, i32* %16
%37 = load i32, i32* %13
%38 = add nsw i32 %36, %37
store i32 %38, i32* %17
%39 = load i32, i32* %17
%40 = load i32, i32* %10
%41 = icmp sgt i32 %39, %40
br i1 %41, label %42, label %44
42: ; preds = %35
%43 = load i32, i32* %10
store i32 %43, i32* %17
br label %44
44: ; preds = %42, %35
%45 = load i32, i32* %15
%46 = load i32, i32* %14
%47 = add nsw i32 %45, %46
store i32 %47, i32* %18
%48 = load i32, i32* %18
%49 = load i32, i32* %11
%50 = icmp sgt i32 %48, %49
br i1 %50, label %51, label %53
51: ; preds = %44
%52 = load i32, i32* %11
store i32 %52, i32* %18
br label %53
53: ; preds = %51, %44
store i32 0, i32* %19
store i32 0, i32* %20
%54 = load i32, i32* %15
store i32 %54, i32* %21
br label %55
55: ; preds = %86, %53
%56 = load i32, i32* %21
%57 = load i32, i32* %18
%58 = icmp slt i32 %56, %57
br i1 %58, label %59, label %89
59: ; preds = %55
%60 = load i32, i32* %16
store i32 %60, i32* %22
br label %61
61: ; preds = %82, %59
%62 = load i32, i32* %22
%63 = load i32, i32* %17
%64 = icmp slt i32 %62, %63
br i1 %64, label %65, label %85
65: ; preds = %61
%66 = load i8*, i8** %7
%67 = load i32, i32* %21
%68 = load i32, i32* %10
%69 = mul nsw i32 %67, %68
%70 = load i32, i32* %22
%71 = add nsw i32 %69, %70
%72 = load i32, i32* %8
%73 = mul nsw i32 %71, %72
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds i8, i8* %66, i64 %74
%76 = load i8, i8* %75
%77 = zext i8 %76 to i32
%78 = load i32, i32* %19
%79 = add nsw i32 %78, %77
store i32 %79, i32* %19
%80 = load i32, i32* %20
%81 = add nsw i32 %80, 1
store i32 %81, i32* %20
br label %82
82: ; preds = %65
%83 = load i32, i32* %22
%84 = add nsw i32 %83, 1
store i32 %84, i32* %22
br label %61
85: ; preds = %61
br label %86
86: ; preds = %85
%87 = load i32, i32* %21
%88 = add nsw i32 %87, 1
store i32 %88, i32* %21
br label %55
89: ; preds = %55
%90 = load i32, i32* %19
%91 = load i32, i32* %20
%92 = sdiv i32 %90, %91
store i32 %92, i32* %23
%93 = load i32, i32* %15
store i32 %93, i32* %21
br label %94
94: ; preds = %142, %89
%95 = load i32, i32* %21
%96 = load i32, i32* %18
%97 = icmp slt i32 %95, %96
br i1 %97, label %98, label %145
98: ; preds = %94
%99 = load i32, i32* %16
store i32 %99, i32* %22
br label %100
100: ; preds = %138, %98
%101 = load i32, i32* %22
%102 = load i32, i32* %17
%103 = icmp slt i32 %101, %102
br i1 %103, label %104, label %141
104: ; preds = %100
%105 = load i8*, i8** %7
%106 = load i32, i32* %21
%107 = load i32, i32* %10
%108 = mul nsw i32 %106, %107
%109 = load i32, i32* %22
%110 = add nsw i32 %108, %109
%111 = load i32, i32* %8
%112 = mul nsw i32 %110, %111
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i8, i8* %105, i64 %113
%115 = load i8, i8* %114
%116 = zext i8 %115 to i32
%117 = load i32, i32* %23
%118 = icmp sgt i32 %116, %117
br i1 %118, label %119, label %128
119: ; preds = %104
%120 = load i8*, i8** %9
%121 = load i32, i32* %21
%122 = load i32, i32* %10
%123 = mul nsw i32 %121, %122
%124 = load i32, i32* %22
%125 = add nsw i32 %123, %124
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i8, i8* %120, i64 %126
store i8 -1, i8* %127
br label %137
128: ; preds = %104
%129 = load i8*, i8** %9
%130 = load i32, i32* %21
%131 = load i32, i32* %10
%132 = mul nsw i32 %130, %131
%133 = load i32, i32* %22
%134 = add nsw i32 %132, %133
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds i8, i8* %129, i64 %135
store i8 0, i8* %136
br label %137
137: ; preds = %128, %119
br label %138
138: ; preds = %137
%139 = load i32, i32* %22
%140 = add nsw i32 %139, 1
store i32 %140, i32* %22
br label %100
141: ; preds = %100
br label %142
142: ; preds = %141
%143 = load i32, i32* %21
%144 = add nsw i32 %143, 1
store i32 %144, i32* %21
br label %94
145: ; preds = %94
br label %146
146: ; preds = %145
%147 = load i32, i32* %13
%148 = load i32, i32* %16
%149 = add nsw i32 %148, %147
store i32 %149, i32* %16
br label %31
150: ; preds = %31
br label %151
151: ; preds = %150
%152 = load i32, i32* %14
%153 = load i32, i32* %15
%154 = add nsw i32 %153, %152
store i32 %154, i32* %15
br label %26
155: ; preds = %26
ret void
}

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