#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*/ memcpy(unsigned char *, unsigned char *, int);
int /*<<< orphan*/ memset(unsigned char *, int /*<<< orphan*/, int);
int dilate9(unsigned char *img, int width, int height, void *buffer) {
  int y, i, sum = 0, widx;
  unsigned char *row1, *row2, *row3, *rowTemp, *yp;
  unsigned char window[3], blob, latest;
  row1 = buffer;
  row2 = row1 + width;
  row3 = row2 + width;
  memset(row2, 0, width);
  memcpy(row3, img, width);
  yp = img;
  for (y = 0; y < height; y++) {
    rowTemp = row1;
    row1 = row2;
    row2 = row3;
    row3 = rowTemp;
    if (y == height - 1)
      memset(row3, 0, width);
    else
      memcpy(row3, yp + width, width);
    window[0] = ((row1[0]) > (row2[0])
                     ? ((row1[0]) > (row3[0]) ? (row1[0]) : (row3[0]))
                     : ((row2[0]) > (row3[0]) ? (row2[0]) : (row3[0])));
    window[1] = ((row1[1]) > (row2[1])
                     ? ((row1[1]) > (row3[1]) ? (row1[1]) : (row3[1]))
                     : ((row2[1]) > (row3[1]) ? (row2[1]) : (row3[1])));
    blob = ((window[0]) > (window[1]) ? (window[0]) : (window[1]));
    widx = 2;
    for (i = 2; i <= width - 1; i++) {
      latest = window[widx] =
          ((row1[i]) > (row2[i])
               ? ((row1[i]) > (row3[i]) ? (row1[i]) : (row3[i]))
               : ((row2[i]) > (row3[i]) ? (row2[i]) : (row3[i])));
      if (latest >= blob)
        blob = latest;
      else
        blob = ((window[0]) > (window[1])
                    ? ((window[0]) > (window[2]) ? (window[0]) : (window[2]))
                    : ((window[1]) > (window[2]) ? (window[1]) : (window[2])));
      if (blob != 0) {
        *(yp + i - 1) = blob;
        sum++;
      }
      if (++widx == 3)
        widx = 0;
    }
    *yp = *(yp + width - 1) = 0;
    yp += width;
  }
  return sum;
}


x86 assembly (clang, -O0):
<dilate9>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movslq -0xc(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0xc(%rbp),%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x40(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0xc(%rbp),%edx
call   1040 <memcpy@plt>
mov    -0x8(%rbp),%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    154e <dilate9+0x42e>
mov    -0x30(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    11e3 <dilate9+0xc3>
mov    -0x40(%rbp),%rdi
mov    -0xc(%rbp),%edx
xor    %esi,%esi
call   1030 <memset@plt>
jmp    11fa <dilate9+0xda>
mov    -0x40(%rbp),%rdi
mov    -0x50(%rbp),%rsi
movslq -0xc(%rbp),%rax
add    %rax,%rsi
mov    -0xc(%rbp),%edx
call   1040 <memcpy@plt>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
mov    -0x38(%rbp),%rcx
movzbl (%rcx),%ecx
cmp    %ecx,%eax
jle    124a <dilate9+0x12a>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
cmp    %ecx,%eax
jle    1235 <dilate9+0x115>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x5c(%rbp)
jmp    123f <dilate9+0x11f>
mov    -0x40(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
jmp    127f <dilate9+0x15f>
mov    -0x38(%rbp),%rax
movzbl (%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
cmp    %ecx,%eax
jle    126f <dilate9+0x14f>
mov    -0x38(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x64(%rbp)
jmp    1279 <dilate9+0x159>
mov    -0x40(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    %al,-0x53(%rbp)
mov    -0x30(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    -0x38(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
cmp    %ecx,%eax
jle    12db <dilate9+0x1bb>
mov    -0x30(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
cmp    %ecx,%eax
jle    12c5 <dilate9+0x1a5>
mov    -0x30(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    %eax,-0x68(%rbp)
jmp    12d0 <dilate9+0x1b0>
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    1314 <dilate9+0x1f4>
mov    -0x38(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
cmp    %ecx,%eax
jle    1303 <dilate9+0x1e3>
mov    -0x38(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    %eax,-0x70(%rbp)
jmp    130e <dilate9+0x1ee>
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    %al,-0x52(%rbp)
movzbl -0x53(%rbp),%eax
movzbl -0x52(%rbp),%ecx
cmp    %ecx,%eax
jle    1336 <dilate9+0x216>
movzbl -0x53(%rbp),%eax
mov    %eax,-0x74(%rbp)
jmp    133d <dilate9+0x21d>
movzbl -0x52(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    %al,-0x54(%rbp)
movl   $0x2,-0x28(%rbp)
movl   $0x2,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     151b <dilate9+0x3fb>
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x38(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jle    13d0 <dilate9+0x2b0>
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jle    13b6 <dilate9+0x296>
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x78(%rbp)
jmp    13c5 <dilate9+0x2a5>
mov    -0x40(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x7c(%rbp)
jmp    1419 <dilate9+0x2f9>
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jle    1404 <dilate9+0x2e4>
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x80(%rbp)
jmp    1413 <dilate9+0x2f3>
mov    -0x40(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
movslq -0x28(%rbp),%rcx
mov    %al,-0x53(%rbp,%rcx,1)
mov    %al,-0x55(%rbp)
movzbl -0x55(%rbp),%eax
movzbl -0x54(%rbp),%ecx
cmp    %ecx,%eax
jl     1442 <dilate9+0x322>
mov    -0x55(%rbp),%al
mov    %al,-0x54(%rbp)
jmp    14ca <dilate9+0x3aa>
movzbl -0x53(%rbp),%eax
movzbl -0x52(%rbp),%ecx
cmp    %ecx,%eax
jle    148c <dilate9+0x36c>
movzbl -0x53(%rbp),%eax
movzbl -0x51(%rbp),%ecx
cmp    %ecx,%eax
jle    1471 <dilate9+0x351>
movzbl -0x53(%rbp),%eax
mov    %eax,-0x84(%rbp)
jmp    147b <dilate9+0x35b>
movzbl -0x51(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x88(%rbp)
jmp    14c1 <dilate9+0x3a1>
movzbl -0x52(%rbp),%eax
movzbl -0x51(%rbp),%ecx
cmp    %ecx,%eax
jle    14ab <dilate9+0x38b>
movzbl -0x52(%rbp),%eax
mov    %eax,-0x8c(%rbp)
jmp    14b5 <dilate9+0x395>
movzbl -0x51(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    %al,-0x54(%rbp)
movzbl -0x54(%rbp),%eax
cmp    $0x0,%eax
je     14ef <dilate9+0x3cf>
mov    -0x54(%rbp),%dl
mov    -0x50(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,-0x1(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
cmp    $0x3,%eax
jne    1508 <dilate9+0x3e8>
movl   $0x0,-0x28(%rbp)
jmp    150d <dilate9+0x3ed>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1351 <dilate9+0x231>
mov    -0x50(%rbp),%rax
movslq -0xc(%rbp),%rcx
movb   $0x0,-0x1(%rax,%rcx,1)
mov    -0x50(%rbp),%rax
movb   $0x0,(%rax)
mov    -0xc(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1193 <dilate9+0x73>
mov    -0x24(%rbp),%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dilate9>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rcx,%r13
mov    %rdx,0x18(%rsp)
mov    %esi,0x10(%rsp)
mov    %rdi,%r15
movslq %esi,%rbx
lea    (%rcx,%rbx,1),%r12
lea    (%r12,%rbx,1),%rbp
xor    %r14d,%r14d
mov    %r12,%rdi
xor    %esi,%esi
mov    %ebx,%edx
call   1030 <memset@plt>
mov    %rbp,%rdi
mov    %r15,%rsi
mov    %rbx,0x30(%rsp)
mov    %ebx,%edx
call   1040 <memcpy@plt>
mov    0x10(%rsp),%edx
cmpl   $0x0,0x18(%rsp)
jle    1314 <dilate9+0x1f4>
mov    %r15,%rcx
mov    0x18(%rsp),%rax
add    $0xffffffff,%eax
mov    %eax,0x24(%rsp)
mov    %edx,%eax
mov    %rax,0x28(%rsp)
xor    %r11d,%r11d
xor    %r14d,%r14d
jmp    11d0 <dilate9+0xb0>
cs nopw 0x0(%rax,%rax,1)
mov    %rbx,%r8
mov    0x14(%rsp),%r11d
mov    0x30(%rsp),%rax
movb   $0x0,-0x1(%r8,%rax,1)
movb   $0x0,(%r8)
lea    (%r8,%rax,1),%rcx
add    $0x1,%r11d
mov    %r13,%rbp
mov    %r15,%r13
cmp    0x18(%rsp),%r11d
je     1314 <dilate9+0x1f4>
mov    %r12,%r15
mov    %rbp,%r12
cmp    0x24(%rsp),%r11d
mov    %r11d,0x14(%rsp)
jne    1200 <dilate9+0xe0>
mov    %rcx,%rbx
mov    %r13,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
jmp    1214 <dilate9+0xf4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x30(%rsp),%rax
mov    %rcx,%rbx
lea    (%rcx,%rax,1),%rsi
mov    %r13,%rdi
call   1040 <memcpy@plt>
xor    %r10d,%r10d
mov    0x28(%rsp),%r9
mov    0x10(%rsp),%edx
movzbl (%r15),%ecx
movzbl (%r12),%eax
cmp    %al,%cl
movzbl 0x0(%r13),%esi
cmova  %ecx,%eax
cmp    %sil,%al
cmovbe %esi,%eax
mov    %al,0xd(%rsp)
movzbl 0x1(%r15),%edi
movzbl 0x1(%r12),%ecx
cmp    %cl,%dil
movzbl 0x1(%r13),%esi
cmova  %edi,%ecx
cmp    %sil,%cl
cmovbe %esi,%ecx
mov    %cl,0xe(%rsp)
cmp    $0x3,%edx
jl     11a0 <dilate9+0x80>
cmp    %cl,%al
movzbl %al,%eax
movzbl %cl,%ebp
cmova  %eax,%ebp
mov    $0x2,%eax
mov    $0x2,%ecx
mov    %rbx,%r8
mov    0x14(%rsp),%r11d
jmp    12c4 <dilate9+0x1a4>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %sil,%bl
movzbl %bl,%edi
movzbl %sil,%esi
cmova  %edi,%esi
mov    %esi,%ebp
test   %sil,%sil
je     1310 <dilate9+0x1f0>
mov    %bpl,-0x1(%r8,%rcx,1)
add    $0x1,%r14d
add    $0x1,%eax
cmp    $0x3,%eax
cmove  %r10d,%eax
add    $0x1,%rcx
cmp    %rcx,%r9
je     11a8 <dilate9+0x88>
movzbl (%r15,%rcx,1),%edi
movzbl (%r12,%rcx,1),%esi
cmp    %sil,%dil
movzbl 0x0(%r13,%rcx,1),%ebx
cmova  %edi,%esi
cmp    %bl,%sil
cmovbe %ebx,%esi
movslq %eax,%rdi
mov    %sil,0xd(%rsp,%rdi,1)
cmp    %bpl,%sil
jae    129d <dilate9+0x17d>
movzbl 0xd(%rsp),%ebp
movzbl 0xe(%rsp),%ebx
movzbl 0xf(%rsp),%esi
cmp    %bl,%bpl
jbe    1290 <dilate9+0x170>
cmp    %sil,%bpl
jbe    129d <dilate9+0x17d>
jmp    12a4 <dilate9+0x184>
nopl   0x0(%rax,%rax,1)
xor    %ebp,%ebp
jmp    12ad <dilate9+0x18d>
mov    %r14d,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @dilate9(i8* %0, i32 %1, i32 %2, i8* %3) {
%5 = alloca [3 x i8]
%6 = getelementptr inbounds [3 x i8], [3 x i8]* %5, i64 0, i64 0
%7 = sext i32 %1 to i64
%8 = getelementptr inbounds i8, i8* %3, i64 %7
%9 = getelementptr inbounds i8, i8* %8, i64 %7
%10 = tail call i32 @memset(i8* %8, i32 0, i32 %1)
%11 = tail call i32 @memcpy(i8* %9, i8* %0, i32 %1)
%12 = icmp sgt i32 %2, 0
br i1 %12, label %13, label %103
13: ; preds = %4
%14 = add nsw i32 %2, -1
%15 = getelementptr inbounds [3 x i8], [3 x i8]* %5, i64 0, i64 1
%16 = icmp sgt i32 %1, 2
%17 = getelementptr inbounds [3 x i8], [3 x i8]* %5, i64 0, i64 2
%18 = zext i32 %1 to i64
br label %19
19: ; preds = %13, %97
%20 = phi i32 [ 0, %13 ], [ %101, %97 ]
%21 = phi i8* [ %0, %13 ], [ %99, %97 ]
%22 = phi i8* [ %9, %13 ], [ %24, %97 ]
%23 = phi i8* [ %8, %13 ], [ %22, %97 ]
%24 = phi i8* [ %3, %13 ], [ %23, %97 ]
%25 = phi i32 [ 0, %13 ], [ %98, %97 ]
%26 = icmp eq i32 %20, %14
br i1 %26, label %27, label %29
27: ; preds = %19
%28 = tail call i32 @memset(i8* %24, i32 0, i32 %1)
br label %32
29: ; preds = %19
%30 = getelementptr inbounds i8, i8* %21, i64 %7
%31 = tail call i32 @memcpy(i8* %24, i8* %30, i32 %1)
br label %32
32: ; preds = %29, %27
%33 = load i8, i8* %23
%34 = load i8, i8* %22
%35 = icmp ugt i8 %33, %34
%36 = load i8, i8* %24
%37 = select i1 %35, i8 %33, i8 %34
%38 = icmp ugt i8 %37, %36
%39 = select i1 %38, i8 %37, i8 %36
store i8 %39, i8* %6
%40 = getelementptr inbounds i8, i8* %23, i64 1
%41 = load i8, i8* %40
%42 = getelementptr inbounds i8, i8* %22, i64 1
%43 = load i8, i8* %42
%44 = icmp ugt i8 %41, %43
%45 = getelementptr inbounds i8, i8* %24, i64 1
%46 = load i8, i8* %45
%47 = select i1 %44, i8 %41, i8 %43
%48 = icmp ugt i8 %47, %46
%49 = select i1 %48, i8 %47, i8 %46
store i8 %49, i8* %15
br i1 %16, label %50, label %97
50: ; preds = %32
%51 = icmp ugt i8 %39, %49
%52 = select i1 %51, i8 %39, i8 %49
%53 = getelementptr inbounds i8, i8* %21, i64 -1
br label %54
54: ; preds = %50, %89
%55 = phi i64 [ 2, %50 ], [ %95, %89 ]
%56 = phi i8 [ %52, %50 ], [ %90, %89 ]
%57 = phi i32 [ 2, %50 ], [ %94, %89 ]
%58 = phi i32 [ %25, %50 ], [ %91, %89 ]
%59 = getelementptr inbounds i8, i8* %23, i64 %55
%60 = load i8, i8* %59
%61 = getelementptr inbounds i8, i8* %22, i64 %55
%62 = load i8, i8* %61
%63 = icmp ugt i8 %60, %62
%64 = getelementptr inbounds i8, i8* %24, i64 %55
%65 = load i8, i8* %64
%66 = select i1 %63, i8 %60, i8 %62
%67 = icmp ugt i8 %66, %65
%68 = select i1 %67, i8 %66, i8 %65
%69 = sext i32 %57 to i64
%70 = getelementptr inbounds [3 x i8], [3 x i8]* %5, i64 0, i64 %69
store i8 %68, i8* %70
%71 = icmp ult i8 %68, %56
br i1 %71, label %72, label %82
72: ; preds = %54
%73 = load i8, i8* %6
%74 = load i8, i8* %15
%75 = icmp ugt i8 %73, %74
%76 = load i8, i8* %17
br i1 %75, label %77, label %79
77: ; preds = %72
%78 = icmp ugt i8 %73, %76
br i1 %78, label %85, label %82
79: ; preds = %72
%80 = icmp ugt i8 %74, %76
%81 = select i1 %80, i8 %74, i8 %76
br label %82
82: ; preds = %77, %79, %54
%83 = phi i8 [ %68, %54 ], [ %76, %77 ], [ %81, %79 ]
%84 = icmp eq i8 %83, 0
br i1 %84, label %89, label %85
85: ; preds = %77, %82
%86 = phi i8 [ %83, %82 ], [ %73, %77 ]
%87 = getelementptr inbounds i8, i8* %53, i64 %55
store i8 %86, i8* %87
%88 = add nsw i32 %58, 1
br label %89
89: ; preds = %85, %82
%90 = phi i8 [ %86, %85 ], [ 0, %82 ]
%91 = phi i32 [ %88, %85 ], [ %58, %82 ]
%92 = add nsw i32 %57, 1
%93 = icmp eq i32 %92, 3
%94 = select i1 %93, i32 0, i32 %92
%95 = add nuw nsw i64 %55, 1
%96 = icmp eq i64 %95, %18
br i1 %96, label %97, label %54
97: ; preds = %89, %32
%98 = phi i32 [ %25, %32 ], [ %91, %89 ]
%99 = getelementptr inbounds i8, i8* %21, i64 %7
%100 = getelementptr inbounds i8, i8* %99, i64 -1
store i8 0, i8* %100
store i8 0, i8* %21
%101 = add nuw nsw i32 %20, 1
%102 = icmp eq i32 %101, %2
br i1 %102, label %103, label %19
103: ; preds = %97, %4
%104 = phi i32 [ 0, %4 ], [ %98, %97 ]
ret i32 %104
}