#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ assert(int);
int /*<<< orphan*/ memset(unsigned char *, int /*<<< orphan*/, unsigned int);
void stbtt__h_prefilter(unsigned char *pixels, int w, int h,
                        int stride_in_bytes, unsigned int kernel_width) {
  unsigned char buffer[8];
  int safe_w = w - kernel_width;
  int j;
  memset(buffer, 0, 8);
  for (j = 0; j < h; ++j) {
    int i;
    unsigned int total;
    memset(buffer, 0, kernel_width);
    total = 0;
    switch (kernel_width) {
    case 2:
      for (i = 0; i <= safe_w; ++i) {
        total += pixels[i] - buffer[i & (8 - 1)];
        buffer[(i + kernel_width) & (8 - 1)] = pixels[i];
        pixels[i] = (unsigned char)(total / 2);
      }
      break;
    case 3:
      for (i = 0; i <= safe_w; ++i) {
        total += pixels[i] - buffer[i & (8 - 1)];
        buffer[(i + kernel_width) & (8 - 1)] = pixels[i];
        pixels[i] = (unsigned char)(total / 3);
      }
      break;
    case 4:
      for (i = 0; i <= safe_w; ++i) {
        total += pixels[i] - buffer[i & (8 - 1)];
        buffer[(i + kernel_width) & (8 - 1)] = pixels[i];
        pixels[i] = (unsigned char)(total / 4);
      }
      break;
    case 5:
      for (i = 0; i <= safe_w; ++i) {
        total += pixels[i] - buffer[i & (8 - 1)];
        buffer[(i + kernel_width) & (8 - 1)] = pixels[i];
        pixels[i] = (unsigned char)(total / 5);
      }
      break;
    default:
      for (i = 0; i <= safe_w; ++i) {
        total += pixels[i] - buffer[i & (8 - 1)];
        buffer[(i + kernel_width) & (8 - 1)] = pixels[i];
        pixels[i] = (unsigned char)(total / kernel_width);
      }
      break;
    }
    for (; i < w; ++i) {
      assert(pixels[i] == 0);
      total -= buffer[i & (8 - 1)];
      pixels[i] = (unsigned char)(total / kernel_width);
    }
    pixels += stride_in_bytes;
  }
}


x86 assembly (clang, -O0):
<stbtt__h_prefilter>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    -0xc(%rbp),%eax
sub    -0x18(%rbp),%eax
mov    %eax,-0x24(%rbp)
lea    -0x20(%rbp),%rdi
xor    %esi,%esi
mov    $0x8,%edx
call   1030 <memset@plt>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    147e <stbtt__h_prefilter+0x35e>
mov    -0x18(%rbp),%edx
lea    -0x20(%rbp),%rdi
xor    %esi,%esi
call   1030 <memset@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x18(%rbp),%eax
add    $0xfffffffe,%eax
mov    %eax,%ecx
mov    %rcx,-0x38(%rbp)
sub    $0x3,%eax
ja     1383 <stbtt__h_prefilter+0x263>
mov    -0x38(%rbp),%rax
lea    0xe66(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1213 <stbtt__h_prefilter+0xf3>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x2c(%rbp),%ecx
and    $0x7,%ecx
movslq %ecx,%rcx
movzbl -0x20(%rbp,%rcx,1),%ecx
sub    %ecx,%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x2c(%rbp),%eax
add    -0x18(%rbp),%eax
and    $0x7,%eax
mov    %eax,%eax
mov    %cl,-0x20(%rbp,%rax,1)
mov    -0x30(%rbp),%eax
shr    $0x1,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11aa <stbtt__h_prefilter+0x8a>
jmp    13fa <stbtt__h_prefilter+0x2da>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     128e <stbtt__h_prefilter+0x16e>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x2c(%rbp),%ecx
and    $0x7,%ecx
movslq %ecx,%rcx
movzbl -0x20(%rbp,%rcx,1),%ecx
sub    %ecx,%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x2c(%rbp),%eax
add    -0x18(%rbp),%eax
and    $0x7,%eax
mov    %eax,%eax
mov    %cl,-0x20(%rbp,%rax,1)
mov    -0x30(%rbp),%eax
mov    $0x3,%ecx
xor    %edx,%edx
div    %ecx
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    121f <stbtt__h_prefilter+0xff>
jmp    13fa <stbtt__h_prefilter+0x2da>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1303 <stbtt__h_prefilter+0x1e3>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x2c(%rbp),%ecx
and    $0x7,%ecx
movslq %ecx,%rcx
movzbl -0x20(%rbp,%rcx,1),%ecx
sub    %ecx,%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x2c(%rbp),%eax
add    -0x18(%rbp),%eax
and    $0x7,%eax
mov    %eax,%eax
mov    %cl,-0x20(%rbp,%rax,1)
mov    -0x30(%rbp),%eax
shr    $0x2,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    129a <stbtt__h_prefilter+0x17a>
jmp    13fa <stbtt__h_prefilter+0x2da>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     137e <stbtt__h_prefilter+0x25e>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x2c(%rbp),%ecx
and    $0x7,%ecx
movslq %ecx,%rcx
movzbl -0x20(%rbp,%rcx,1),%ecx
sub    %ecx,%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x2c(%rbp),%eax
add    -0x18(%rbp),%eax
and    $0x7,%eax
mov    %eax,%eax
mov    %cl,-0x20(%rbp,%rax,1)
mov    -0x30(%rbp),%eax
mov    $0x5,%ecx
xor    %edx,%edx
div    %ecx
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    130f <stbtt__h_prefilter+0x1ef>
jmp    13fa <stbtt__h_prefilter+0x2da>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     13f5 <stbtt__h_prefilter+0x2d5>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x2c(%rbp),%ecx
and    $0x7,%ecx
movslq %ecx,%rcx
movzbl -0x20(%rbp,%rcx,1),%ecx
sub    %ecx,%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x2c(%rbp),%eax
add    -0x18(%rbp),%eax
and    $0x7,%eax
mov    %eax,%eax
mov    %cl,-0x20(%rbp,%rax,1)
mov    -0x30(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    138a <stbtt__h_prefilter+0x26a>
jmp    13fa <stbtt__h_prefilter+0x2da>
jmp    13ff <stbtt__h_prefilter+0x2df>
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    145f <stbtt__h_prefilter+0x33f>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    -0x2c(%rbp),%eax
and    $0x7,%eax
cltq
movzbl -0x20(%rbp,%rax,1),%ecx
mov    -0x30(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13ff <stbtt__h_prefilter+0x2df>
mov    -0x14(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1159 <stbtt__h_prefilter+0x39>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<stbtt__h_prefilter>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r8d,%r13d
mov    %ecx,%r14d
mov    %edx,%ebx
mov    %esi,%r15d
mov    %rdi,%rbp
lea    0x8(%rsp),%rdi
xor    %r12d,%r12d
xor    %esi,%esi
mov    $0x8,%edx
call   1030 <memset@plt>
mov    %ebx,0x18(%rsp)
test   %ebx,%ebx
jle    14b8 <stbtt__h_prefilter+0x398>
mov    %r15d,%eax
sub    %r13d,%eax
movslq %r14d,%rcx
mov    %rcx,0x40(%rsp)
mov    %rax,0x10(%rsp)
lea    0x1(%rax),%r14d
lea    -0x1(%r14),%rax
mov    %rax,0x28(%rsp)
mov    %r14d,%eax
and    $0xfffffffe,%eax
mov    %rax,0x20(%rsp)
mov    %r13d,%eax
mov    %rax,0x30(%rsp)
lea    -0x2(%r13),%ebx
mov    %rbx,0x38(%rsp)
jmp    11be <stbtt__h_prefilter+0x9e>
nopw   0x0(%rax,%rax,1)
add    0x40(%rsp),%rbp
mov    0x1c(%rsp),%r12d
add    $0x1,%r12d
cmp    0x18(%rsp),%r12d
mov    0x38(%rsp),%rbx
je     14b8 <stbtt__h_prefilter+0x398>
lea    0x8(%rsp),%rdi
xor    %esi,%esi
mov    %r13d,%edx
call   1030 <memset@plt>
cmp    $0x3,%ebx
mov    %r12d,0x1c(%rsp)
ja     1270 <stbtt__h_prefilter+0x150>
lea    0xe1e(%rip),%rcx
movslq (%rcx,%rbx,4),%rax
add    %rcx,%rax
jmp    *%rax
cmpl   $0x0,0x10(%rsp)
js     1400 <stbtt__h_prefilter+0x2e0>
cmpq   $0x0,0x28(%rsp)
je     1406 <stbtt__h_prefilter+0x2e6>
xor    %ecx,%ecx
xor    %ebx,%ebx
mov    0x20(%rsp),%r8
nopl   0x0(%rax,%rax,1)
movzbl 0x0(%rbp,%rcx,1),%edx
mov    %ecx,%eax
and    $0x6,%eax
movzbl 0x8(%rsp,%rax,1),%esi
lea    0x2(%rcx),%rax
mov    %eax,%edi
and    $0x6,%edi
mov    %dl,0x8(%rsp,%rdi,1)
sub    %esi,%edx
add    %ebx,%edx
mov    %edx,%esi
shr    %esi
mov    %sil,0x0(%rbp,%rcx,1)
lea    0x1(%rcx),%esi
movzbl 0x1(%rbp,%rcx,1),%edi
and    $0x7,%esi
movzbl 0x8(%rsp,%rsi,1),%esi
lea    0x3(%rcx),%ebx
and    $0x7,%ebx
mov    %dil,0x8(%rsp,%rbx,1)
mov    %edi,%ebx
sub    %esi,%ebx
add    %edx,%ebx
mov    %ebx,%edx
shr    %edx
mov    %dl,0x1(%rbp,%rcx,1)
mov    %rax,%rcx
cmp    %rax,%r8
jne    1210 <stbtt__h_prefilter+0xf0>
jmp    140a <stbtt__h_prefilter+0x2ea>
nop
cmpl   $0x0,0x10(%rsp)
js     1400 <stbtt__h_prefilter+0x2e0>
xor    %ecx,%ecx
xor    %ebx,%ebx
mov    0x30(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl 0x0(%rbp,%rcx,1),%eax
lea    (%rdi,%rcx,1),%edx
mov    %ecx,%esi
and    $0x7,%esi
movzbl 0x8(%rsp,%rsi,1),%esi
and    $0x7,%edx
mov    %al,0x8(%rsp,%rdx,1)
sub    %esi,%eax
add    %eax,%ebx
mov    %ebx,%eax
xor    %edx,%edx
div    %r13d
mov    %al,0x0(%rbp,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%r14
jne    1290 <stbtt__h_prefilter+0x170>
jmp    1469 <stbtt__h_prefilter+0x349>
cs nopw 0x0(%rax,%rax,1)
cmpl   $0x0,0x10(%rsp)
js     1400 <stbtt__h_prefilter+0x2e0>
xor    %eax,%eax
xor    %ebx,%ebx
mov    $0xaaaaaaab,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl 0x0(%rbp,%rax,1),%ecx
mov    %eax,%edx
and    $0x7,%edx
movzbl 0x8(%rsp,%rdx,1),%edx
lea    0x3(%rax),%esi
and    $0x7,%esi
mov    %cl,0x8(%rsp,%rsi,1)
sub    %edx,%ecx
add    %ecx,%ebx
mov    %rbx,%rcx
imul   %rdi,%rcx
shr    $0x21,%rcx
mov    %cl,0x0(%rbp,%rax,1)
add    $0x1,%rax
cmp    %rax,%r14
jne    12f0 <stbtt__h_prefilter+0x1d0>
jmp    1469 <stbtt__h_prefilter+0x349>
nopw   0x0(%rax,%rax,1)
cmpl   $0x0,0x10(%rsp)
js     1400 <stbtt__h_prefilter+0x2e0>
cmpq   $0x0,0x28(%rsp)
je     1436 <stbtt__h_prefilter+0x316>
xor    %eax,%eax
xor    %ebx,%ebx
mov    0x20(%rsp),%r8
movzbl 0x0(%rbp,%rax,1),%ecx
mov    %eax,%edx
and    $0x6,%edx
movzbl 0x8(%rsp,%rdx,1),%edx
lea    0x4(%rax),%esi
and    $0x6,%esi
mov    %cl,0x8(%rsp,%rsi,1)
sub    %edx,%ecx
add    %ebx,%ecx
mov    %ecx,%edx
shr    $0x2,%edx
mov    %dl,0x0(%rbp,%rax,1)
lea    0x1(%rax),%edx
movzbl 0x1(%rbp,%rax,1),%esi
and    $0x7,%edx
movzbl 0x8(%rsp,%rdx,1),%edx
lea    0x5(%rax),%edi
and    $0x7,%edi
mov    %sil,0x8(%rsp,%rdi,1)
mov    %esi,%ebx
sub    %edx,%ebx
add    %ecx,%ebx
mov    %ebx,%ecx
shr    $0x2,%ecx
mov    %cl,0x1(%rbp,%rax,1)
add    $0x2,%rax
cmp    %rax,%r8
jne    1350 <stbtt__h_prefilter+0x230>
jmp    143a <stbtt__h_prefilter+0x31a>
xchg   %ax,%ax
cmpl   $0x0,0x10(%rsp)
js     1400 <stbtt__h_prefilter+0x2e0>
xor    %eax,%eax
xor    %ebx,%ebx
mov    $0xcccccccd,%edi
movzbl 0x0(%rbp,%rax,1),%ecx
mov    %eax,%edx
and    $0x7,%edx
movzbl 0x8(%rsp,%rdx,1),%edx
lea    0x5(%rax),%esi
and    $0x7,%esi
mov    %cl,0x8(%rsp,%rsi,1)
sub    %edx,%ecx
add    %ecx,%ebx
mov    %rbx,%rcx
imul   %rdi,%rcx
shr    $0x22,%rcx
mov    %cl,0x0(%rbp,%rax,1)
add    $0x1,%rax
cmp    %rax,%r14
jne    13c0 <stbtt__h_prefilter+0x2a0>
jmp    1469 <stbtt__h_prefilter+0x349>
nopw   0x0(%rax,%rax,1)
xor    %ecx,%ecx
xor    %ebx,%ebx
jmp    146c <stbtt__h_prefilter+0x34c>
xor    %eax,%eax
xor    %ebx,%ebx
mov    %r14d,%ecx
test   $0x1,%r14b
je     146c <stbtt__h_prefilter+0x34c>
movzbl 0x0(%rbp,%rax,1),%ecx
mov    %eax,%edx
and    $0x7,%edx
movzbl 0x8(%rsp,%rdx,1),%edx
lea    0x2(%rax),%esi
and    $0x7,%esi
mov    %cl,0x8(%rsp,%rsi,1)
sub    %edx,%ecx
add    %ebx,%ecx
mov    %ecx,%ebx
shr    %ecx
jmp    1465 <stbtt__h_prefilter+0x345>
xor    %eax,%eax
xor    %ebx,%ebx
mov    %r14d,%ecx
test   $0x1,%r14b
je     146c <stbtt__h_prefilter+0x34c>
movzbl 0x0(%rbp,%rax,1),%ecx
mov    %eax,%edx
and    $0x7,%edx
movzbl 0x8(%rsp,%rdx,1),%edx
lea    0x4(%rax),%esi
and    $0x7,%esi
mov    %cl,0x8(%rsp,%rsi,1)
sub    %edx,%ecx
add    %ebx,%ecx
mov    %ecx,%ebx
shr    $0x2,%ecx
mov    %cl,0x0(%rbp,%rax,1)
mov    %r14d,%ecx
cmp    %r15d,%ecx
jge    11a0 <stbtt__h_prefilter+0x80>
mov    %ecx,%r12d
nopl   0x0(%rax,%rax,1)
xor    %edi,%edi
cmpb   $0x0,0x0(%rbp,%r12,1)
sete   %dil
call   1040 <assert@plt>
mov    %r12d,%eax
and    $0x7,%eax
movzbl 0x8(%rsp,%rax,1),%eax
sub    %eax,%ebx
mov    %ebx,%eax
xor    %edx,%edx
div    %r13d
mov    %al,0x0(%rbp,%r12,1)
add    $0x1,%r12
cmp    %r15d,%r12d
jl     1480 <stbtt__h_prefilter+0x360>
jmp    11a0 <stbtt__h_prefilter+0x80>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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