#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*/ free(unsigned int *);
scalar_t__ malloc(int);
int /*<<< orphan*/ manhattan_distance_dilate_1D(unsigned int *, int, int);
int /*<<< orphan*/ printf(char *, int);
int dilate_1D(unsigned char *image_data, int width, int height,
              unsigned int dilate_by_k) {
  unsigned int idx = 0;
  unsigned int *image_data_uint = NULL;
  image_data_uint =
      (unsigned int *)malloc((width * height) * sizeof(unsigned int));
  if (image_data_uint == NULL) {
    printf("final_stage:Could not allocate %d bytes.\n",
           ((width * height) * sizeof(unsigned int)));
    return 0;
  } else {
    for (idx = 0; idx < (width * height); idx++)
      image_data_uint[idx] = (unsigned int)image_data[idx];
  }
  manhattan_distance_dilate_1D(image_data_uint, width, height);
  for (idx = 0; idx < (height * width); idx++) {
    image_data_uint[idx] = ((image_data_uint[idx] <= dilate_by_k) ? 255 : 0);
    image_data[idx] = (unsigned char)image_data_uint[idx];
  }
  free(image_data_uint);
  return 1;
}


x86 assembly (clang, -O0):
<dilate_1D>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jne    11ae <dilate_1D+0x6e>
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%esi
lea    0xe63(%rip),%rdi
call   1050 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    126e <dilate_1D+0x12e>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
cmp    %ecx,%eax
jae    11ea <dilate_1D+0xaa>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
movzbl (%rax,%rcx,1),%edx
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11b5 <dilate_1D+0x75>
jmp    11ef <dilate_1D+0xaf>
mov    -0x28(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
call   1040 <manhattan_distance_dilate_1D@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
imul   -0x14(%rbp),%ecx
cmp    %ecx,%eax
jae    125e <dilate_1D+0x11e>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    (%rax,%rcx,4),%ecx
mov    -0x1c(%rbp),%esi
xor    %edx,%edx
mov    $0xff,%eax
cmp    %esi,%ecx
cmovbe %eax,%edx
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1205 <dilate_1D+0xc5>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dilate_1D>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %ecx,%r14d
mov    %esi,%r12d
mov    %rdi,%rbp
mov    %edx,0x4(%rsp)
mov    %edx,%r15d
imul   %esi,%r15d
lea    0x0(,%r15,4),%r13d
mov    %r13d,%edi
call   1060 <malloc@plt>
test   %rax,%rax
je     1211 <dilate_1D+0xd1>
mov    %rax,%rbx
test   %r15d,%r15d
je     1227 <dilate_1D+0xe7>
mov    %r15d,%r13d
cmp    $0x8,%r15d
jb     11a9 <dilate_1D+0x69>
mov    %rbp,%rax
add    %r13,%rax
cmp    %rbx,%rax
jbe    123b <dilate_1D+0xfb>
lea    (%rbx,%r13,4),%rax
cmp    %rbp,%rax
jbe    123b <dilate_1D+0xfb>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r13,%rcx
mov    %r13,%rdx
and    $0x3,%rdx
je     11d2 <dilate_1D+0x92>
nopl   (%rax)
movzbl 0x0(%rbp,%rax,1),%esi
mov    %esi,(%rbx,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    11c0 <dilate_1D+0x80>
cmp    $0x3,%rcx
jb     1302 <dilate_1D+0x1c2>
nopl   0x0(%rax)
movzbl 0x0(%rbp,%rax,1),%ecx
mov    %ecx,(%rbx,%rax,4)
movzbl 0x1(%rbp,%rax,1),%ecx
mov    %ecx,0x4(%rbx,%rax,4)
movzbl 0x2(%rbp,%rax,1),%ecx
mov    %ecx,0x8(%rbx,%rax,4)
movzbl 0x3(%rbp,%rax,1),%ecx
mov    %ecx,0xc(%rbx,%rax,4)
add    $0x4,%rax
cmp    %rax,%r13
jne    11e0 <dilate_1D+0xa0>
jmp    1302 <dilate_1D+0x1c2>
lea    0xe08(%rip),%rdi
mov    %r13d,%esi
call   1050 <printf@plt>
xor    %eax,%eax
jmp    1550 <dilate_1D+0x410>
mov    %rbx,%rdi
mov    %r12d,%esi
mov    0x4(%rsp),%edx
call   1040 <manhattan_distance_dilate_1D@plt>
jmp    1543 <dilate_1D+0x403>
mov    %r13d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     155f <dilate_1D+0x41f>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
movd   0x0(%rbp,%rcx,1),%xmm1
movd   0x4(%rbp,%rcx,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rcx,4)
movdqu %xmm2,0x10(%rbx,%rcx,4)
movd   0x8(%rbp,%rcx,1),%xmm1
movd   0xc(%rbp,%rcx,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
movdqu %xmm1,0x20(%rbx,%rcx,4)
movdqu %xmm2,0x30(%rbx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1270 <dilate_1D+0x130>
test   $0x1,%dl
je     12f9 <dilate_1D+0x1b9>
movd   0x0(%rbp,%rcx,1),%xmm0
movd   0x4(%rbp,%rcx,1),%xmm1
pxor   %xmm2,%xmm2
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
movdqu %xmm0,(%rbx,%rcx,4)
movdqu %xmm1,0x10(%rbx,%rcx,4)
cmp    %r13,%rax
jne    11ab <dilate_1D+0x6b>
mov    %rbx,%rdi
mov    %r12d,%esi
mov    0x4(%rsp),%edx
call   1040 <manhattan_distance_dilate_1D@plt>
test   %r15d,%r15d
je     1543 <dilate_1D+0x403>
cmp    $0x8,%r15d
jb     1338 <dilate_1D+0x1f8>
mov    %rbp,%rax
add    %r13,%rax
cmp    %rbx,%rax
jbe    13ac <dilate_1D+0x26c>
lea    (%rbx,%r13,4),%rax
cmp    %rbp,%rax
jbe    13ac <dilate_1D+0x26c>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%r13b
je     1360 <dilate_1D+0x220>
xor    %edx,%edx
cmp    %r14d,(%rbx,%rax,4)
mov    $0xff,%esi
cmova  %edx,%esi
mov    %esi,(%rbx,%rax,4)
mov    %sil,0x0(%rbp,%rax,1)
or     $0x1,%rax
add    %r13,%rcx
jne    1385 <dilate_1D+0x245>
jmp    1543 <dilate_1D+0x403>
nopw   0x0(%rax,%rax,1)
mov    %ecx,0x4(%rbx,%rax,4)
mov    %cl,0x1(%rbp,%rax,1)
add    $0x2,%rax
cmp    %rax,%r13
je     1543 <dilate_1D+0x403>
xor    %ecx,%ecx
mov    $0x0,%edx
cmp    %r14d,(%rbx,%rax,4)
ja     1397 <dilate_1D+0x257>
mov    $0xff,%edx
mov    %edx,(%rbx,%rax,4)
mov    %dl,0x0(%rbp,%rax,1)
cmp    %r14d,0x4(%rbx,%rax,4)
ja     1370 <dilate_1D+0x230>
mov    $0xff,%ecx
jmp    1370 <dilate_1D+0x230>
mov    %r13d,%eax
and    $0xfffffff8,%eax
movd   %r14d,%xmm0
pshufd $0x0,%xmm0,%xmm8
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     156f <dilate_1D+0x42f>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
movdqa 0xc1a(%rip),%xmm1
movdqa %xmm8,%xmm2
pxor   %xmm1,%xmm2
pcmpeqd %xmm3,%xmm3
movdqa 0xc15(%rip),%xmm4
nopl   0x0(%rax,%rax,1)
movdqu (%rbx,%rcx,4),%xmm5
movdqu 0x10(%rbx,%rcx,4),%xmm0
pxor   %xmm1,%xmm5
pcmpgtd %xmm2,%xmm5
movdqa %xmm5,%xmm7
pxor   %xmm3,%xmm7
packssdw %xmm7,%xmm7
packsswb %xmm7,%xmm7
pandn  %xmm4,%xmm5
pxor   %xmm1,%xmm0
pcmpgtd %xmm2,%xmm0
movdqa %xmm0,%xmm6
pxor   %xmm3,%xmm6
packssdw %xmm6,%xmm6
packsswb %xmm6,%xmm6
pandn  %xmm4,%xmm0
movdqu %xmm5,(%rbx,%rcx,4)
movdqu %xmm0,0x10(%rbx,%rcx,4)
movd   %xmm7,0x0(%rbp,%rcx,1)
movd   %xmm6,0x4(%rbp,%rcx,1)
movdqu 0x20(%rbx,%rcx,4),%xmm0
movdqu 0x30(%rbx,%rcx,4),%xmm5
pxor   %xmm1,%xmm0
pcmpgtd %xmm2,%xmm0
movdqa %xmm0,%xmm6
pxor   %xmm3,%xmm6
packssdw %xmm6,%xmm6
packsswb %xmm6,%xmm6
pandn  %xmm4,%xmm0
pxor   %xmm1,%xmm5
pcmpgtd %xmm2,%xmm5
movdqa %xmm5,%xmm7
pxor   %xmm3,%xmm7
packssdw %xmm7,%xmm7
packsswb %xmm7,%xmm7
pandn  %xmm4,%xmm5
movdqu %xmm0,0x20(%rbx,%rcx,4)
movdqu %xmm5,0x30(%rbx,%rcx,4)
movd   %xmm6,0x8(%rbp,%rcx,1)
movd   %xmm7,0xc(%rbp,%rcx,1)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1400 <dilate_1D+0x2c0>
test   $0x1,%dl
je     153a <dilate_1D+0x3fa>
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
movdqa 0xb24(%rip),%xmm2
pxor   %xmm2,%xmm8
pxor   %xmm2,%xmm0
pcmpgtd %xmm8,%xmm0
pcmpeqd %xmm3,%xmm3
movdqa %xmm0,%xmm4
pxor   %xmm3,%xmm4
movdqa 0xb12(%rip),%xmm5
pandn  %xmm5,%xmm0
pxor   %xmm2,%xmm1
pcmpgtd %xmm8,%xmm1
pxor   %xmm1,%xmm3
pandn  %xmm5,%xmm1
movdqu %xmm0,(%rbx,%rcx,4)
movdqu %xmm1,0x10(%rbx,%rcx,4)
packssdw %xmm4,%xmm4
packsswb %xmm4,%xmm4
packssdw %xmm3,%xmm3
packsswb %xmm3,%xmm3
movd   %xmm4,0x0(%rbp,%rcx,1)
movd   %xmm3,0x4(%rbp,%rcx,1)
cmp    %r13,%rax
jne    133a <dilate_1D+0x1fa>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    $0x1,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ecx,%ecx
test   $0x1,%dl
jne    12ce <dilate_1D+0x18e>
jmp    12f9 <dilate_1D+0x1b9>
xor    %ecx,%ecx
test   $0x1,%dl
jne    14c9 <dilate_1D+0x389>
jmp    153a <dilate_1D+0x3fa>

LLVM IR (-O0):
@.str = [42 x i8] c"final_stage:Could not allocate %d bytes.\0A\00"
define i32 @dilate_1D(i8* %0, i32 %1, i32 %2, i32 %3) {
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32*
store i8* %0, i8** %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store i32 0, i32* %10
store i32* null, i32** %11
%12 = load i32, i32* %7
%13 = load i32, i32* %8
%14 = mul nsw i32 %12, %13
%15 = sext i32 %14 to i64
%16 = mul i64 %15, 4
%17 = trunc i64 %16 to i32
%18 = call i64 @malloc(i32 %17)
%19 = inttoptr i64 %18 to i32*
store i32* %19, i32** %11
%20 = load i32*, i32** %11
%21 = icmp eq i32* %20, null
br i1 %21, label %22, label %30
22: ; preds = %4
%23 = load i32, i32* %7
%24 = load i32, i32* %8
%25 = mul nsw i32 %23, %24
%26 = sext i32 %25 to i64
%27 = mul i64 %26, 4
%28 = trunc i64 %27 to i32
%29 = call i32 @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str, i64 0, i64 0), i32 %28)
store i32 0, i32* %5
br label %93
30: ; preds = %4
store i32 0, i32* %10
br label %31
31: ; preds = %48, %30
%32 = load i32, i32* %10
%33 = load i32, i32* %7
%34 = load i32, i32* %8
%35 = mul nsw i32 %33, %34
%36 = icmp ult i32 %32, %35
br i1 %36, label %37, label %51
37: ; preds = %31
%38 = load i8*, i8** %6
%39 = load i32, i32* %10
%40 = zext i32 %39 to i64
%41 = getelementptr inbounds i8, i8* %38, i64 %40
%42 = load i8, i8* %41
%43 = zext i8 %42 to i32
%44 = load i32*, i32** %11
%45 = load i32, i32* %10
%46 = zext i32 %45 to i64
%47 = getelementptr inbounds i32, i32* %44, i64 %46
store i32 %43, i32* %47
br label %48
48: ; preds = %37
%49 = load i32, i32* %10
%50 = add i32 %49, 1
store i32 %50, i32* %10
br label %31
51: ; preds = %31
br label %52
52: ; preds = %51
%53 = load i32*, i32** %11
%54 = load i32, i32* %7
%55 = load i32, i32* %8
%56 = call i32 @manhattan_distance_dilate_1D(i32* %53, i32 %54, i32 %55)
store i32 0, i32* %10
br label %57
57: ; preds = %87, %52
%58 = load i32, i32* %10
%59 = load i32, i32* %8
%60 = load i32, i32* %7
%61 = mul nsw i32 %59, %60
%62 = icmp ult i32 %58, %61
br i1 %62, label %63, label %90
63: ; preds = %57
%64 = load i32*, i32** %11
%65 = load i32, i32* %10
%66 = zext i32 %65 to i64
%67 = getelementptr inbounds i32, i32* %64, i64 %66
%68 = load i32, i32* %67
%69 = load i32, i32* %9
%70 = icmp ule i32 %68, %69
%71 = zext i1 %70 to i64
%72 = select i1 %70, i32 255, i32 0
%73 = load i32*, i32** %11
%74 = load i32, i32* %10
%75 = zext i32 %74 to i64
%76 = getelementptr inbounds i32, i32* %73, i64 %75
store i32 %72, i32* %76
%77 = load i32*, i32** %11
%78 = load i32, i32* %10
%79 = zext i32 %78 to i64
%80 = getelementptr inbounds i32, i32* %77, i64 %79
%81 = load i32, i32* %80
%82 = trunc i32 %81 to i8
%83 = load i8*, i8** %6
%84 = load i32, i32* %10
%85 = zext i32 %84 to i64
%86 = getelementptr inbounds i8, i8* %83, i64 %85
store i8 %82, i8* %86
br label %87
87: ; preds = %63
%88 = load i32, i32* %10
%89 = add i32 %88, 1
store i32 %89, i32* %10
br label %57
90: ; preds = %57
%91 = load i32*, i32** %11
%92 = call i32 @free(i32* %91)
store i32 1, i32* %5
br label %93
93: ; preds = %90, %22
%94 = load i32, i32* %5
ret i32 %94
}

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