int edge_region(the_image, out_image, edge_type, min_area, max_area, diff,
                percent, set_value, erode, rows, cols, bits_per_pixel)
float percent;
int edge_type;
long bits_per_pixel, cols, rows;
short diff, erode, max_area, min_area, set_value, **the_image, **out_image;
{
  int a, b, count, i, j, k, length, width;
  short cutoff;
  unsigned long histogram[255 + 1];
  if (edge_type == 1 || edge_type == 2 || edge_type == 3)
    detect_edges(the_image, out_image, edge_type, 0, 0, rows, cols,
                 bits_per_pixel);
  if (edge_type == 4) {
    quick_edge(the_image, out_image, 0, 0, rows, cols, bits_per_pixel);
  }
  if (edge_type == 5) {
    homogeneity(the_image, out_image, rows, cols, bits_per_pixel, 0, 0);
  }
  if (edge_type == 6) {
    difference_edge(the_image, out_image, rows, cols, bits_per_pixel, 0, 0);
  }
  if (edge_type == 7) {
    contrast_edge(the_image, out_image, rows, cols, bits_per_pixel, 0, 0);
  }
  if (edge_type == 8) {
    gaussian_edge(the_image, out_image, rows, cols, bits_per_pixel, 3, 0, 0);
  }
  if (edge_type == 10) {
    range(the_image, out_image, rows, cols, bits_per_pixel, 3, 0, 0);
  }
  if (edge_type == 11) {
    variance(the_image, out_image, rows, cols, bits_per_pixel, 0, 0);
  }
  for (i = 0; i < rows; i++)
    for (j = 0; j < cols; j++)
      the_image[i][j] = out_image[i][j];
  zero_histogram(histogram, 255 + 1);
  calculate_histogram(the_image, histogram, rows, cols);
  find_cutoff_point(histogram, percent, &cutoff, rows, cols);
  threshold_image_array(the_image, out_image, 255, cutoff, set_value, rows,
                        cols);
  if (erode != 0) {
    for (i = 0; i < rows; i++)
      for (j = 0; j < cols; j++)
        the_image[i][j] = out_image[i][j];
    erode_image_array(the_image, out_image, set_value, erode, rows, cols);
  }
  for (i = 0; i < rows; i++)
    for (j = 0; j < cols; j++)
      if (out_image[i][j] == set_value)
        out_image[i][j] = -50;
  for (i = 0; i < rows; i++)
    for (j = 0; j < cols; j++)
      the_image[i][j] = out_image[i][j];
  pixel_grow(the_image, out_image, diff, min_area, max_area, rows, cols);
  return (1);
}


x86 assembly (clang, -O0):
<edge_region>:
push   %rbp
mov    %rsp,%rbp
sub    $0x870,%rsp
mov    %r9d,-0x85c(%rbp)
mov    %r8d,-0x858(%rbp)
mov    %ecx,-0x854(%rbp)
mov    %edx,%r8d
mov    -0x85c(%rbp),%edx
mov    %rsi,%r9
mov    -0x858(%rbp),%esi
mov    %rdi,%r10
mov    -0x854(%rbp),%edi
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%ecx
cvtsd2ss %xmm0,%xmm0
mov    %r10,-0x8(%rbp)
mov    %r9,-0x10(%rbp)
mov    %r8d,-0x14(%rbp)
mov    %di,-0x16(%rbp)
mov    %si,-0x18(%rbp)
mov    %dx,-0x1a(%rbp)
movss  %xmm0,-0x20(%rbp)
mov    %cx,-0x22(%rbp)
mov    %ax,-0x24(%rbp)
cmpl   $0x1,-0x14(%rbp)
je     1273 <edge_region+0x93>
cmpl   $0x2,-0x14(%rbp)
je     1273 <edge_region+0x93>
cmpl   $0x3,-0x14(%rbp)
jne    12a0 <edge_region+0xc0>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    0x20(%rbp),%r9
mov    0x28(%rbp),%r10
mov    0x30(%rbp),%rax
xor    %r8d,%r8d
mov    %r8d,%ecx
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   10f0 <detect_edges@plt>
cmpl   $0x4,-0x14(%rbp)
jne    12cd <edge_region+0xed>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    0x20(%rbp),%r8
mov    0x28(%rbp),%r9
mov    0x30(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
mov    %rax,(%rsp)
mov    $0x0,%al
call   1040 <quick_edge@plt>
cmpl   $0x5,-0x14(%rbp)
jne    12fc <edge_region+0x11c>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    0x20(%rbp),%rdx
mov    0x28(%rbp),%rcx
mov    0x30(%rbp),%r8
xor    %r9d,%r9d
movl   $0x0,(%rsp)
mov    $0x0,%al
call   1070 <homogeneity@plt>
cmpl   $0x6,-0x14(%rbp)
jne    132b <edge_region+0x14b>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    0x20(%rbp),%rdx
mov    0x28(%rbp),%rcx
mov    0x30(%rbp),%r8
xor    %r9d,%r9d
movl   $0x0,(%rsp)
mov    $0x0,%al
call   10e0 <difference_edge@plt>
cmpl   $0x7,-0x14(%rbp)
jne    135a <edge_region+0x17a>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    0x20(%rbp),%rdx
mov    0x28(%rbp),%rcx
mov    0x30(%rbp),%r8
xor    %r9d,%r9d
movl   $0x0,(%rsp)
mov    $0x0,%al
call   1060 <contrast_edge@plt>
cmpl   $0x8,-0x14(%rbp)
jne    1396 <edge_region+0x1b6>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    0x20(%rbp),%rdx
mov    0x28(%rbp),%rcx
mov    0x30(%rbp),%r8
mov    $0x3,%r9d
xor    %eax,%eax
movl   $0x0,(%rsp)
movl   $0x0,0x8(%rsp)
mov    $0x0,%al
call   10b0 <gaussian_edge@plt>
cmpl   $0xa,-0x14(%rbp)
jne    13d2 <edge_region+0x1f2>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    0x20(%rbp),%rdx
mov    0x28(%rbp),%rcx
mov    0x30(%rbp),%r8
mov    $0x3,%r9d
xor    %eax,%eax
movl   $0x0,(%rsp)
movl   $0x0,0x8(%rsp)
mov    $0x0,%al
call   10c0 <range@plt>
cmpl   $0xb,-0x14(%rbp)
jne    1401 <edge_region+0x221>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    0x20(%rbp),%rdx
mov    0x28(%rbp),%rcx
mov    0x30(%rbp),%r8
xor    %r9d,%r9d
movl   $0x0,(%rsp)
mov    $0x0,%al
call   1080 <variance@plt>
movl   $0x0,-0x34(%rbp)
movslq -0x34(%rbp),%rax
cmp    0x20(%rbp),%rax
jge    1474 <edge_region+0x294>
movl   $0x0,-0x38(%rbp)
movslq -0x38(%rbp),%rax
cmp    0x28(%rbp),%rax
jge    1461 <edge_region+0x281>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    141d <edge_region+0x23d>
jmp    1466 <edge_region+0x286>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1408 <edge_region+0x228>
lea    -0x850(%rbp),%rdi
mov    $0x100,%esi
mov    $0x0,%al
call   1100 <zero_histogram@plt>
mov    -0x8(%rbp),%rdi
lea    -0x850(%rbp),%rsi
mov    0x20(%rbp),%rdx
mov    0x28(%rbp),%rcx
mov    $0x0,%al
call   1090 <calculate_histogram@plt>
lea    -0x850(%rbp),%rdi
movss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x20(%rbp),%rdx
mov    0x28(%rbp),%rcx
lea    -0x46(%rbp),%rsi
mov    $0x1,%al
call   10d0 <find_cutoff_point@plt>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
movswl -0x46(%rbp),%ecx
movswl -0x22(%rbp),%r8d
mov    0x20(%rbp),%r9
mov    0x28(%rbp),%rax
mov    $0xff,%edx
mov    %rax,(%rsp)
mov    $0x0,%al
call   1050 <threshold_image_array@plt>
movswl -0x24(%rbp),%eax
cmp    $0x0,%eax
je     158c <edge_region+0x3ac>
movl   $0x0,-0x34(%rbp)
movslq -0x34(%rbp),%rax
cmp    0x20(%rbp),%rax
jge    156d <edge_region+0x38d>
movl   $0x0,-0x38(%rbp)
movslq -0x38(%rbp),%rax
cmp    0x28(%rbp),%rax
jge    155a <edge_region+0x37a>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1516 <edge_region+0x336>
jmp    155f <edge_region+0x37f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1501 <edge_region+0x321>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
movswl -0x22(%rbp),%edx
movswl -0x24(%rbp),%ecx
mov    0x20(%rbp),%r8
mov    0x28(%rbp),%r9
mov    $0x0,%al
call   1030 <erode_image_array@plt>
movl   $0x0,-0x34(%rbp)
movslq -0x34(%rbp),%rax
cmp    0x20(%rbp),%rax
jge    1612 <edge_region+0x432>
movl   $0x0,-0x38(%rbp)
movslq -0x38(%rbp),%rax
cmp    0x28(%rbp),%rax
jge    15ff <edge_region+0x41f>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
movswl -0x22(%rbp),%ecx
cmp    %ecx,%eax
jne    15ec <edge_region+0x40c>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movw   $0xffce,(%rax,%rcx,2)
jmp    15f1 <edge_region+0x411>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15a8 <edge_region+0x3c8>
jmp    1604 <edge_region+0x424>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1593 <edge_region+0x3b3>
movl   $0x0,-0x34(%rbp)
movslq -0x34(%rbp),%rax
cmp    0x20(%rbp),%rax
jge    1685 <edge_region+0x4a5>
movl   $0x0,-0x38(%rbp)
movslq -0x38(%rbp),%rax
cmp    0x28(%rbp),%rax
jge    1672 <edge_region+0x492>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    162e <edge_region+0x44e>
jmp    1677 <edge_region+0x497>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1619 <edge_region+0x439>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
movswl -0x1a(%rbp),%edx
movswl -0x16(%rbp),%ecx
movswl -0x18(%rbp),%r8d
mov    0x20(%rbp),%r9
mov    0x28(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   10a0 <pixel_grow@plt>
mov    $0x1,%eax
add    $0x870,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<edge_region>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x858,%rsp
movsd  %xmm0,0x20(%rsp)
mov    %r9d,0x3c(%rsp)
mov    %r8d,0x44(%rsp)
mov    %ecx,0x40(%rsp)
mov    %edx,%r13d
mov    %rsi,%r15
mov    %rdi,0x18(%rsp)
mov    0x8b0(%rsp),%rbp
mov    0x8a8(%rsp),%r12
mov    0x8a0(%rsp),%r14
lea    -0x1(%r13),%eax
cmp    $0x2,%eax
ja     1254 <edge_region+0x74>
mov    %rbp,0x8(%rsp)
mov    %r12,(%rsp)
mov    0x18(%rsp),%rdi
mov    %r15,%rsi
mov    %r13d,%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
mov    %r14,%r9
xor    %eax,%eax
call   10f0 <detect_edges@plt>
add    $0xfffffffc,%r13d
cmp    $0x7,%r13d
ja     1389 <edge_region+0x1a9>
lea    0xd97(%rip),%rax
movslq (%rax,%r13,4),%rcx
add    %rax,%rcx
jmp    *%rcx
mov    %rbp,(%rsp)
mov    0x18(%rsp),%rdi
mov    %r15,%rsi
xor    %edx,%edx
xor    %ecx,%ecx
mov    %r14,%r8
mov    %r12,%r9
xor    %eax,%eax
call   1040 <quick_edge@plt>
jmp    1389 <edge_region+0x1a9>
movl   $0x0,(%rsp)
mov    0x18(%rsp),%rdi
mov    %r15,%rsi
mov    %r14,%rdx
mov    %r12,%rcx
mov    %rbp,%r8
xor    %r9d,%r9d
xor    %eax,%eax
call   1070 <homogeneity@plt>
jmp    1389 <edge_region+0x1a9>
movl   $0x0,(%rsp)
mov    0x18(%rsp),%rdi
mov    %r15,%rsi
mov    %r14,%rdx
mov    %r12,%rcx
mov    %rbp,%r8
xor    %r9d,%r9d
xor    %eax,%eax
call   10e0 <difference_edge@plt>
jmp    1389 <edge_region+0x1a9>
movl   $0x0,(%rsp)
mov    0x18(%rsp),%rdi
mov    %r15,%rsi
mov    %r14,%rdx
mov    %r12,%rcx
mov    %rbp,%r8
xor    %r9d,%r9d
xor    %eax,%eax
call   1060 <contrast_edge@plt>
jmp    1389 <edge_region+0x1a9>
movl   $0x0,0x8(%rsp)
movl   $0x0,(%rsp)
mov    0x18(%rsp),%rdi
mov    %r15,%rsi
mov    %r14,%rdx
mov    %r12,%rcx
mov    %rbp,%r8
mov    $0x3,%r9d
xor    %eax,%eax
call   10c0 <range@plt>
jmp    1389 <edge_region+0x1a9>
movl   $0x0,(%rsp)
mov    0x18(%rsp),%rdi
mov    %r15,%rsi
mov    %r14,%rdx
mov    %r12,%rcx
mov    %rbp,%r8
xor    %r9d,%r9d
xor    %eax,%eax
call   1080 <variance@plt>
jmp    1389 <edge_region+0x1a9>
movl   $0x0,0x8(%rsp)
movl   $0x0,(%rsp)
mov    0x18(%rsp),%rdi
mov    %r15,%rsi
mov    %r14,%rdx
mov    %r12,%rcx
mov    %rbp,%r8
mov    $0x3,%r9d
xor    %eax,%eax
call   10b0 <gaussian_edge@plt>
movsd  0x20(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x30(%rsp)
test   %r14,%r14
jle    156e <edge_region+0x38e>
lea    -0x10(%r12),%r10
mov    %r10,0x20(%rsp)
shr    $0x4,%r10
add    $0x1,%r10
mov    %r12,%r11
and    $0xfffffffffffffff0,%r11
mov    %r10d,%r9d
and    $0x3,%r9d
movabs $0x1ffffffffffffffc,%rax
ff ff 1f
and    %rax,%r10
mov    %r12d,%r13d
and    $0x3,%r13d
mov    %r9,%rsi
shl    $0x5,%rsi
xor    %eax,%eax
jmp    13fd <edge_region+0x21d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %r14,%rax
je     156e <edge_region+0x38e>
test   %r12,%r12
jle    13f0 <edge_region+0x210>
mov    (%r15,%rax,8),%rbp
mov    0x18(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
cmp    $0x10,%r12
jb     1432 <edge_region+0x252>
lea    0x0(,%r12,2),%rdx
add    %rbp,%rdx
cmp    %rdx,%rcx
jae    14a5 <edge_region+0x2c5>
lea    (%rcx,%r12,2),%rdx
cmp    %rdx,%rbp
jae    14a5 <edge_region+0x2c5>
xor    %edx,%edx
mov    %rdx,%rbx
not    %rbx
add    %r12,%rbx
test   %r13,%r13
je     1465 <edge_region+0x285>
mov    %r13,%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movzwl 0x0(%rbp,%rdx,2),%r8d
mov    %r8w,(%rcx,%rdx,2)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1450 <edge_region+0x270>
cmp    $0x3,%rbx
jb     13f0 <edge_region+0x210>
nopl   0x0(%rax,%rax,1)
movzwl 0x0(%rbp,%rdx,2),%edi
mov    %di,(%rcx,%rdx,2)
movzwl 0x2(%rbp,%rdx,2),%edi
mov    %di,0x2(%rcx,%rdx,2)
movzwl 0x4(%rbp,%rdx,2),%edi
mov    %di,0x4(%rcx,%rdx,2)
movzwl 0x6(%rbp,%rdx,2),%edi
mov    %di,0x6(%rcx,%rdx,2)
add    $0x4,%rdx
cmp    %rdx,%r12
jne    1470 <edge_region+0x290>
jmp    13f0 <edge_region+0x210>
cmpq   $0x30,0x20(%rsp)
jae    14b1 <edge_region+0x2d1>
xor    %edx,%edx
jmp    151b <edge_region+0x33b>
mov    %r10,%rbx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movups 0x0(%rbp,%rdx,2),%xmm0
movups 0x10(%rbp,%rdx,2),%xmm1
movups %xmm0,(%rcx,%rdx,2)
movups %xmm1,0x10(%rcx,%rdx,2)
movups 0x20(%rbp,%rdx,2),%xmm0
movups 0x30(%rbp,%rdx,2),%xmm1
movups %xmm0,0x20(%rcx,%rdx,2)
movups %xmm1,0x30(%rcx,%rdx,2)
movups 0x40(%rbp,%rdx,2),%xmm0
movups 0x50(%rbp,%rdx,2),%xmm1
movups %xmm0,0x40(%rcx,%rdx,2)
movups %xmm1,0x50(%rcx,%rdx,2)
movups 0x60(%rbp,%rdx,2),%xmm0
movdqu 0x70(%rbp,%rdx,2),%xmm1
movups %xmm0,0x60(%rcx,%rdx,2)
movdqu %xmm1,0x70(%rcx,%rdx,2)
add    $0x40,%rdx
add    $0xfffffffffffffffc,%rbx
jne    14c0 <edge_region+0x2e0>
test   %r9,%r9
je     155d <edge_region+0x37d>
lea    (%rcx,%rdx,2),%rbx
add    $0x10,%rbx
lea    0x10(,%rdx,2),%rdx
add    %rbp,%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rdx,%rdi,1),%xmm0
movdqu (%rdx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rbx,%rdi,1)
movdqu %xmm1,(%rbx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1540 <edge_region+0x360>
mov    %r11,%rdx
cmp    %r12,%r11
je     13f0 <edge_region+0x210>
jmp    1434 <edge_region+0x254>
lea    0x50(%rsp),%rbp
mov    %rbp,%rdi
mov    $0x100,%esi
xor    %eax,%eax
call   1100 <zero_histogram@plt>
mov    0x18(%rsp),%rbx
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %r14,%rdx
mov    %r12,%rcx
xor    %eax,%eax
call   1090 <calculate_histogram@plt>
movss  0x30(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x2e(%rsp),%rsi
mov    %rbp,%rdi
mov    %r14,%rdx
mov    %r12,%rcx
mov    $0x1,%al
call   10d0 <find_cutoff_point@plt>
movswl 0x2e(%rsp),%ecx
mov    0x890(%rsp),%eax
movswl %ax,%ebp
mov    %r12,(%rsp)
mov    %rbx,%rdi
mov    %r15,%rsi
mov    $0xff,%edx
mov    %ebp,%r8d
mov    %r14,%r9
xor    %eax,%eax
call   1050 <threshold_image_array@plt>
mov    0x898(%rsp),%eax
test   $0xffff,%eax
je     17d9 <edge_region+0x5f9>
cwtl
mov    %eax,0x38(%rsp)
test   %r14,%r14
jle    17be <edge_region+0x5de>
lea    -0x10(%r12),%rax
mov    %rax,0x20(%rsp)
mov    %rax,%rcx
shr    $0x4,%rcx
add    $0x1,%rcx
mov    %r12,%r11
and    $0xfffffffffffffff0,%r11
mov    %ecx,%r9d
and    $0x3,%r9d
movabs $0x1ffffffffffffffc,%rax
ff ff 1f
and    %rax,%rcx
mov    %rcx,0x48(%rsp)
mov    %r12d,%r13d
and    $0x3,%r13d
mov    %r9,0x30(%rsp)
shl    $0x5,%r9
xor    %r8d,%r8d
jmp    165d <edge_region+0x47d>
xchg   %ax,%ax
add    $0x1,%r8
cmp    %r14,%r8
je     17be <edge_region+0x5de>
test   %r12,%r12
jle    1650 <edge_region+0x470>
mov    (%r15,%r8,8),%rsi
mov    0x18(%rsp),%rax
mov    (%rax,%r8,8),%rbx
cmp    $0x10,%r12
jb     1687 <edge_region+0x4a7>
lea    (%rsi,%r12,2),%rax
cmp    %rax,%rbx
jae    16f4 <edge_region+0x514>
lea    (%rbx,%r12,2),%rax
cmp    %rax,%rsi
jae    16f4 <edge_region+0x514>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r12,%rcx
test   %r13,%r13
je     16b2 <edge_region+0x4d2>
mov    %r13,%rdi
nopw   0x0(%rax,%rax,1)
movzwl (%rsi,%rax,2),%edx
mov    %dx,(%rbx,%rax,2)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdi
jne    16a0 <edge_region+0x4c0>
cmp    $0x3,%rcx
jb     1650 <edge_region+0x470>
nopl   0x0(%rax,%rax,1)
movzwl (%rsi,%rax,2),%ecx
mov    %cx,(%rbx,%rax,2)
movzwl 0x2(%rsi,%rax,2),%ecx
mov    %cx,0x2(%rbx,%rax,2)
movzwl 0x4(%rsi,%rax,2),%ecx
mov    %cx,0x4(%rbx,%rax,2)
movzwl 0x6(%rsi,%rax,2),%ecx
mov    %cx,0x6(%rbx,%rax,2)
add    $0x4,%rax
cmp    %rax,%r12
jne    16c0 <edge_region+0x4e0>
jmp    1650 <edge_region+0x470>
cmpq   $0x30,0x20(%rsp)
jae    1700 <edge_region+0x520>
xor    %eax,%eax
jmp    176a <edge_region+0x58a>
mov    0x48(%rsp),%r10
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movups (%rsi,%rax,2),%xmm0
movups 0x10(%rsi,%rax,2),%xmm1
movups %xmm0,(%rbx,%rax,2)
movups %xmm1,0x10(%rbx,%rax,2)
movups 0x20(%rsi,%rax,2),%xmm0
movups 0x30(%rsi,%rax,2),%xmm1
movups %xmm0,0x20(%rbx,%rax,2)
movups %xmm1,0x30(%rbx,%rax,2)
movups 0x40(%rsi,%rax,2),%xmm0
movups 0x50(%rsi,%rax,2),%xmm1
movups %xmm0,0x40(%rbx,%rax,2)
movups %xmm1,0x50(%rbx,%rax,2)
movups 0x60(%rsi,%rax,2),%xmm0
movdqu 0x70(%rsi,%rax,2),%xmm1
movups %xmm0,0x60(%rbx,%rax,2)
movdqu %xmm1,0x70(%rbx,%rax,2)
add    $0x40,%rax
add    $0xfffffffffffffffc,%r10
jne    1710 <edge_region+0x530>
cmpq   $0x0,0x30(%rsp)
je     17ad <edge_region+0x5cd>
lea    (%rbx,%rax,2),%rcx
add    $0x10,%rcx
lea    (%rsi,%rax,2),%rax
add    $0x10,%rax
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x10(%rax,%rdi,1),%xmm0
movdqu (%rax,%rdi,1),%xmm1
movups %xmm0,-0x10(%rcx,%rdi,1)
movdqu %xmm1,(%rcx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    1790 <edge_region+0x5b0>
mov    %r11,%rax
cmp    %r12,%r11
je     1650 <edge_region+0x470>
jmp    1689 <edge_region+0x4a9>
mov    0x18(%rsp),%rdi
mov    %r15,%rsi
mov    %ebp,%edx
mov    0x38(%rsp),%ecx
mov    %r14,%r8
mov    %r12,%r9
xor    %eax,%eax
call   1030 <erode_image_array@plt>
test   %r14,%r14
jle    1b00 <edge_region+0x920>
mov    %r12,%rax
and    $0xfffffffffffffff8,%rax
movd   %ebp,%xmm0
pshufd $0x0,%xmm0,%xmm0
xor    %ecx,%ecx
jmp    180d <edge_region+0x62d>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %r14,%rcx
je     192d <edge_region+0x74d>
test   %r12,%r12
jle    1800 <edge_region+0x620>
mov    (%r15,%rcx,8),%rdx
xor    %esi,%esi
cmp    $0x8,%r12
jb     191d <edge_region+0x73d>
jmp    183d <edge_region+0x65d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x8,%rsi
cmp    %rsi,%rax
je     1900 <edge_region+0x720>
movdqu (%rdx,%rsi,2),%xmm1
punpcklwd %xmm1,%xmm2
psrad  $0x10,%xmm2
pcmpeqd %xmm0,%xmm2
movd   %xmm2,%edi
test   $0x1,%dil
je     185f <edge_region+0x67f>
movw   $0xffce,(%rdx,%rsi,2)
movdqa %xmm2,%xmm3
psrlq  $0x10,%xmm3
movd   %xmm3,%edi
shr    $0x10,%edi
test   $0x1,%dil
je     187c <edge_region+0x69c>
movw   $0xffce,0x2(%rdx,%rsi,2)
pextrw $0x4,%xmm2,%edi
test   $0x1,%dil
je     188e <edge_region+0x6ae>
movw   $0xffce,0x4(%rdx,%rsi,2)
pextrw $0x6,%xmm2,%edi
test   $0x1,%dil
je     18a0 <edge_region+0x6c0>
movw   $0xffce,0x6(%rdx,%rsi,2)
punpckhwd %xmm1,%xmm1
psrad  $0x10,%xmm1
pcmpeqd %xmm0,%xmm1
pextrw $0x0,%xmm1,%edi
test   $0x1,%dil
je     18bf <edge_region+0x6df>
movw   $0xffce,0x8(%rdx,%rsi,2)
pextrw $0x2,%xmm1,%edi
test   $0x1,%dil
je     18d1 <edge_region+0x6f1>
movw   $0xffce,0xa(%rdx,%rsi,2)
pextrw $0x4,%xmm1,%edi
test   $0x1,%dil
je     18e3 <edge_region+0x703>
movw   $0xffce,0xc(%rdx,%rsi,2)
pextrw $0x7,%xmm1,%edi
test   $0x1,%dil
je     1830 <edge_region+0x650>
movw   $0xffce,0xe(%rdx,%rsi,2)
jmp    1830 <edge_region+0x650>
xchg   %ax,%ax
mov    %rax,%rsi
cmp    %r12,%rax
jne    191d <edge_region+0x73d>
jmp    1800 <edge_region+0x620>
nopl   (%rax)
add    $0x1,%rsi
cmp    %rsi,%r12
je     1800 <edge_region+0x620>
movswl (%rdx,%rsi,2),%edi
cmp    %edi,%ebp
jne    1910 <edge_region+0x730>
movw   $0xffce,(%rdx,%rsi,2)
jmp    1910 <edge_region+0x730>
test   %r14,%r14
jle    1b00 <edge_region+0x920>
lea    -0x10(%r12),%r10
mov    %r10,0x20(%rsp)
shr    $0x4,%r10
add    $0x1,%r10
mov    %r12,%r11
and    $0xfffffffffffffff0,%r11
mov    %r10d,%r9d
and    $0x3,%r9d
movabs $0x1ffffffffffffffc,%rax
ff ff 1f
and    %rax,%r10
mov    %r12d,%r13d
and    $0x3,%r13d
mov    %r9,%rsi
shl    $0x5,%rsi
xor    %eax,%eax
jmp    198d <edge_region+0x7ad>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rax
cmp    %r14,%rax
je     1b00 <edge_region+0x920>
test   %r12,%r12
jle    1980 <edge_region+0x7a0>
mov    (%r15,%rax,8),%rbp
mov    0x18(%rsp),%rcx
mov    (%rcx,%rax,8),%rbx
cmp    $0x10,%r12
jb     19c2 <edge_region+0x7e2>
lea    0x0(,%r12,2),%rcx
add    %rbp,%rcx
cmp    %rcx,%rbx
jae    1a35 <edge_region+0x855>
lea    (%rbx,%r12,2),%rcx
cmp    %rcx,%rbp
jae    1a35 <edge_region+0x855>
xor    %edx,%edx
mov    %rdx,%rcx
not    %rcx
add    %r12,%rcx
test   %r13,%r13
je     19f5 <edge_region+0x815>
mov    %r13,%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movzwl 0x0(%rbp,%rdx,2),%r8d
mov    %r8w,(%rbx,%rdx,2)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    19e0 <edge_region+0x800>
cmp    $0x3,%rcx
jb     1980 <edge_region+0x7a0>
nopl   0x0(%rax,%rax,1)
movzwl 0x0(%rbp,%rdx,2),%ecx
mov    %cx,(%rbx,%rdx,2)
movzwl 0x2(%rbp,%rdx,2),%ecx
mov    %cx,0x2(%rbx,%rdx,2)
movzwl 0x4(%rbp,%rdx,2),%ecx
mov    %cx,0x4(%rbx,%rdx,2)
movzwl 0x6(%rbp,%rdx,2),%ecx
mov    %cx,0x6(%rbx,%rdx,2)
add    $0x4,%rdx
cmp    %rdx,%r12
jne    1a00 <edge_region+0x820>
jmp    1980 <edge_region+0x7a0>
cmpq   $0x30,0x20(%rsp)
jae    1a41 <edge_region+0x861>
xor    %edx,%edx
jmp    1aad <edge_region+0x8cd>
mov    %r10,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movups 0x0(%rbp,%rdx,2),%xmm0
movups 0x10(%rbp,%rdx,2),%xmm1
movups %xmm0,(%rbx,%rdx,2)
movups %xmm1,0x10(%rbx,%rdx,2)
movups 0x20(%rbp,%rdx,2),%xmm0
movups 0x30(%rbp,%rdx,2),%xmm1
movups %xmm0,0x20(%rbx,%rdx,2)
movups %xmm1,0x30(%rbx,%rdx,2)
movups 0x40(%rbp,%rdx,2),%xmm0
movups 0x50(%rbp,%rdx,2),%xmm1
movups %xmm0,0x40(%rbx,%rdx,2)
movups %xmm1,0x50(%rbx,%rdx,2)
movdqu 0x60(%rbp,%rdx,2),%xmm0
movdqu 0x70(%rbp,%rdx,2),%xmm1
movdqu %xmm0,0x60(%rbx,%rdx,2)
movdqu %xmm1,0x70(%rbx,%rdx,2)
add    $0x40,%rdx
add    $0xfffffffffffffffc,%rcx
jne    1a50 <edge_region+0x870>
test   %r9,%r9
je     1aef <edge_region+0x90f>
lea    (%rbx,%rdx,2),%rcx
add    $0x10,%rcx
lea    0x10(,%rdx,2),%rdx
add    %rbp,%rdx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rdx,%rdi,1),%xmm0
movdqu (%rdx,%rdi,1),%xmm1
movdqu %xmm0,-0x10(%rcx,%rdi,1)
movdqu %xmm1,(%rcx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1ad0 <edge_region+0x8f0>
mov    %r11,%rdx
cmp    %r12,%r11
je     1980 <edge_region+0x7a0>
jmp    19c4 <edge_region+0x7e4>
movswl 0x3c(%rsp),%edx
movswl 0x40(%rsp),%ecx
movswl 0x44(%rsp),%r8d
mov    %r12,(%rsp)
mov    0x18(%rsp),%rdi
mov    %r15,%rsi
mov    %r14,%r9
xor    %eax,%eax
call   10a0 <pixel_grow@plt>
mov    $0x1,%eax
add    $0x858,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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