#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(float *);
int /*<<< orphan*/ morsi_dilation(float *, float *, int, int, int *);
int /*<<< orphan*/ morsi_erosion(float *, float *, int, int, int *);
float *xmalloc(int);
void morsi_all(float *o_ero, float *o_dil, float *o_ope, float *o_clo,
               float *o_grad, float *o_igrad, float *o_egrad, float *o_lap,
               float *o_enh, float *o_str, float *o_top, float *o_bot, float *x,
               int w, int h, int *e) {
  int n = w * h, s = n * sizeof(float), own_ope = 0, own_clo = 0, own_lap = 0,
      i;
  float *min = xmalloc(s);
  float *max = xmalloc(s);
  if ((o_top || o_str) && !o_ope) {
    o_ope = xmalloc(s);
    own_ope = 1;
  }
  if ((o_bot || o_str) && !o_clo) {
    o_clo = xmalloc(s);
    own_clo = 1;
  }
  if (o_enh && !o_lap) {
    o_lap = xmalloc(s);
    own_lap = 1;
  }
  morsi_erosion(min, x, w, h, e);
  morsi_dilation(max, x, w, h, e);
  if (o_ero)
    for (i = 0; i < n; i++)
      o_ero[i] = min[i];
  if (o_dil)
    for (i = 0; i < n; i++)
      o_dil[i] = max[i];
  if (o_ope)
    morsi_dilation(o_ope, min, w, h, e);
  if (o_clo)
    morsi_erosion(o_clo, max, w, h, e);
  if (o_grad)
    for (i = 0; i < n; i++)
      o_grad[i] = max[i] - min[i];
  if (o_igrad)
    for (i = 0; i < n; i++)
      o_igrad[i] = x[i] - min[i];
  if (o_egrad)
    for (i = 0; i < n; i++)
      o_egrad[i] = max[i] - x[i];
  if (o_top)
    for (i = 0; i < n; i++)
      o_top[i] = x[i] - o_ope[i];
  if (o_bot)
    for (i = 0; i < n; i++)
      o_bot[i] = o_clo[i] - x[i];
  if (o_str)
    for (i = 0; i < n; i++)
      o_str[i] = o_clo[i] - o_ope[i];
  if (o_lap)
    for (i = 0; i < n; i++)
      o_lap[i] = (max[i] + min[i] - 2 * x[i]) / 2;
  if (o_enh)
    for (i = 0; i < n; i++)
      o_enh[i] = x[i] - o_lap[i];
  free(min);
  free(max);
  if (own_ope)
    free(o_ope);
  if (own_clo)
    free(o_clo);
  if (own_lap)
    free(o_lap);
}


x86 assembly (clang, -O0):
<morsi_all>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%eax
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    0x48(%rbp),%eax
imul   0x50(%rbp),%eax
mov    %eax,-0x34(%rbp)
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x38(%rbp),%edi
call   1050 <xmalloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%edi
call   1050 <xmalloc@plt>
mov    %rax,-0x58(%rbp)
cmpq   $0x0,0x30(%rbp)
jne    11de <morsi_all+0x9e>
cmpq   $0x0,0x28(%rbp)
je     11fc <morsi_all+0xbc>
cmpq   $0x0,-0x18(%rbp)
jne    11fc <morsi_all+0xbc>
mov    -0x38(%rbp),%edi
call   1050 <xmalloc@plt>
mov    %rax,-0x18(%rbp)
movl   $0x1,-0x3c(%rbp)
cmpq   $0x0,0x38(%rbp)
jne    1212 <morsi_all+0xd2>
cmpq   $0x0,0x28(%rbp)
je     1230 <morsi_all+0xf0>
cmpq   $0x0,-0x20(%rbp)
jne    1230 <morsi_all+0xf0>
mov    -0x38(%rbp),%edi
call   1050 <xmalloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x1,-0x40(%rbp)
cmpq   $0x0,0x20(%rbp)
je     1259 <morsi_all+0x119>
cmpq   $0x0,0x18(%rbp)
jne    1259 <morsi_all+0x119>
mov    -0x38(%rbp),%edi
call   1050 <xmalloc@plt>
mov    %rax,0x18(%rbp)
movl   $0x1,-0x44(%rbp)
mov    -0x50(%rbp),%rdi
mov    0x40(%rbp),%rsi
mov    0x48(%rbp),%edx
mov    0x50(%rbp),%ecx
mov    0x58(%rbp),%r8
call   1060 <morsi_erosion@plt>
mov    -0x58(%rbp),%rdi
mov    0x40(%rbp),%rsi
mov    0x48(%rbp),%edx
mov    0x50(%rbp),%ecx
mov    0x58(%rbp),%r8
call   1040 <morsi_dilation@plt>
cmpq   $0x0,-0x8(%rbp)
je     12d2 <morsi_all+0x192>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    12cd <morsi_all+0x18d>
mov    -0x50(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1299 <morsi_all+0x159>
jmp    12d2 <morsi_all+0x192>
cmpq   $0x0,-0x10(%rbp)
je     131d <morsi_all+0x1dd>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1318 <morsi_all+0x1d8>
mov    -0x58(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    12e4 <morsi_all+0x1a4>
jmp    131d <morsi_all+0x1dd>
cmpq   $0x0,-0x18(%rbp)
je     133f <morsi_all+0x1ff>
mov    -0x18(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    0x48(%rbp),%edx
mov    0x50(%rbp),%ecx
mov    0x58(%rbp),%r8
call   1040 <morsi_dilation@plt>
cmpq   $0x0,-0x20(%rbp)
je     1361 <morsi_all+0x221>
mov    -0x20(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    0x48(%rbp),%edx
mov    0x50(%rbp),%ecx
mov    0x58(%rbp),%r8
call   1060 <morsi_erosion@plt>
cmpq   $0x0,-0x28(%rbp)
je     13b9 <morsi_all+0x279>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    13b4 <morsi_all+0x274>
mov    -0x58(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x48(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1373 <morsi_all+0x233>
jmp    13b9 <morsi_all+0x279>
cmpq   $0x0,-0x30(%rbp)
je     1411 <morsi_all+0x2d1>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    140c <morsi_all+0x2cc>
mov    0x40(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x48(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    13cb <morsi_all+0x28b>
jmp    1411 <morsi_all+0x2d1>
cmpq   $0x0,0x10(%rbp)
je     1469 <morsi_all+0x329>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1464 <morsi_all+0x324>
mov    -0x58(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x40(%rbp),%rax
movslq -0x48(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1423 <morsi_all+0x2e3>
jmp    1469 <morsi_all+0x329>
cmpq   $0x0,0x30(%rbp)
je     14c1 <morsi_all+0x381>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    14bc <morsi_all+0x37c>
mov    0x40(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x30(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    147b <morsi_all+0x33b>
jmp    14c1 <morsi_all+0x381>
cmpq   $0x0,0x38(%rbp)
je     1519 <morsi_all+0x3d9>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1514 <morsi_all+0x3d4>
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x40(%rbp),%rax
movslq -0x48(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x38(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    14d3 <morsi_all+0x393>
jmp    1519 <morsi_all+0x3d9>
cmpq   $0x0,0x28(%rbp)
je     1571 <morsi_all+0x431>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    156c <morsi_all+0x42c>
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x28(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    152b <morsi_all+0x3eb>
jmp    1571 <morsi_all+0x431>
cmpq   $0x0,0x18(%rbp)
je     15ea <morsi_all+0x4aa>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    15e5 <morsi_all+0x4a5>
mov    -0x58(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x48(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x40(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
addss  %xmm1,%xmm1
subss  %xmm1,%xmm0
movss  0xa3a(%rip),%xmm1
divss  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1583 <morsi_all+0x443>
jmp    15ea <morsi_all+0x4aa>
cmpq   $0x0,0x20(%rbp)
je     1642 <morsi_all+0x502>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    163d <morsi_all+0x4fd>
mov    0x40(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    15fc <morsi_all+0x4bc>
jmp    1642 <morsi_all+0x502>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
cmpl   $0x0,-0x3c(%rbp)
je     1667 <morsi_all+0x527>
mov    -0x18(%rbp),%rdi
call   1030 <free@plt>
cmpl   $0x0,-0x40(%rbp)
je     167a <morsi_all+0x53a>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
cmpl   $0x0,-0x44(%rbp)
je     168d <morsi_all+0x54d>
mov    0x18(%rbp),%rdi
call   1030 <free@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<morsi_all>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9,0x30(%rsp)
mov    %r8,0x70(%rsp)
mov    %rcx,0x60(%rsp)
mov    %rdx,0x50(%rsp)
mov    %rsi,%r12
mov    %rdi,%r14
mov    0xf8(%rsp),%rax
mov    %rax,0x48(%rsp)
mov    0xf0(%rsp),%ecx
mov    0xe8(%rsp),%edx
mov    0xe0(%rsp),%rbx
mov    0xd8(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    0xd0(%rsp),%rax
mov    %rax,(%rsp)
mov    0xc8(%rsp),%r15
mov    0xc0(%rsp),%rax
mov    %rax,0x28(%rsp)
mov    %ecx,0x24(%rsp)
mov    %edx,0x20(%rsp)
imul   %edx,%ecx
mov    0xb8(%rsp),%rax
mov    %rax,0x58(%rsp)
mov    0xb0(%rsp),%rax
mov    %rax,0x38(%rsp)
mov    %rcx,0x18(%rsp)
lea    0x0(,%rcx,4),%ebp
mov    %ebp,%edi
call   1050 <xmalloc@plt>
mov    %rax,%r13
mov    %ebp,%edi
call   1050 <xmalloc@plt>
mov    %r15,%rdx
mov    %rax,%r15
mov    %rdx,%rax
or     (%rsp),%rax
setne  %al
cmpq   $0x0,0x50(%rsp)
sete   %cl
and    %al,%cl
mov    %cl,0xf(%rsp)
cmp    $0x1,%cl
mov    %rdx,0x40(%rsp)
jne    1235 <morsi_all+0xf5>
mov    %ebp,%edi
call   1050 <xmalloc@plt>
mov    0x40(%rsp),%rdx
mov    %rax,0x50(%rsp)
mov    %rdx,%rax
or     0x10(%rsp),%rax
setne  %al
cmpq   $0x0,0x60(%rsp)
sete   %cl
and    %al,%cl
mov    %cl,0xe(%rsp)
cmp    $0x1,%cl
jne    1260 <morsi_all+0x120>
mov    %ebp,%edi
call   1050 <xmalloc@plt>
mov    %rax,0x60(%rsp)
cmpq   $0x0,0x28(%rsp)
sete   %al
cmpq   $0x0,0x58(%rsp)
setne  %cl
or     %al,%cl
mov    %cl,0xd(%rsp)
jne    1286 <morsi_all+0x146>
mov    %ebp,%edi
call   1050 <xmalloc@plt>
mov    %rax,0x58(%rsp)
mov    %r13,%rdi
mov    %rbx,%rsi
mov    0x20(%rsp),%edx
mov    0x24(%rsp),%ecx
mov    0x48(%rsp),%rbp
mov    %rbp,%r8
call   1060 <morsi_erosion@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    0x20(%rsp),%edx
mov    0x24(%rsp),%ecx
mov    %rbp,%r8
call   1040 <morsi_dilation@plt>
mov    0x18(%rsp),%r8
mov    %r8d,%r11d
test   %r14,%r14
je     1474 <morsi_all+0x334>
test   %r8d,%r8d
jle    1474 <morsi_all+0x334>
cmp    $0x8,%r8d
jb     12f8 <morsi_all+0x1b8>
lea    0x0(,%r11,4),%rax
add    %r13,%rax
cmp    %r14,%rax
jbe    1385 <morsi_all+0x245>
lea    (%r14,%r11,4),%rax
cmp    %rax,%r13
jae    1385 <morsi_all+0x245>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r11,%rcx
mov    %r11,%rdx
and    $0x3,%rdx
je     1327 <morsi_all+0x1e7>
nopl   0x0(%rax)
movss  0x0(%r13,%rax,4),%xmm0
movss  %xmm0,(%r14,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1310 <morsi_all+0x1d0>
cmp    $0x3,%rcx
jb     1474 <morsi_all+0x334>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x0(%r13,%rax,4),%xmm0
movss  %xmm0,(%r14,%rax,4)
movss  0x4(%r13,%rax,4),%xmm0
movss  %xmm0,0x4(%r14,%rax,4)
movss  0x8(%r13,%rax,4),%xmm0
movss  %xmm0,0x8(%r14,%rax,4)
movss  0xc(%r13,%rax,4),%xmm0
movss  %xmm0,0xc(%r14,%rax,4)
add    $0x4,%rax
cmp    %rax,%r11
jne    1340 <morsi_all+0x200>
jmp    1474 <morsi_all+0x334>
mov    %r11d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    13ac <morsi_all+0x26c>
xor    %esi,%esi
jmp    1429 <morsi_all+0x2e9>
movabs $0x3ffffffffffffffe,%rsi
ff ff 3f
add    $0xfffffffffffffffe,%rsi
and    %rsi,%rdx
xor    %esi,%esi
nop
movups 0x0(%r13,%rsi,4),%xmm0
movups 0x10(%r13,%rsi,4),%xmm1
movups %xmm0,(%r14,%rsi,4)
movups %xmm1,0x10(%r14,%rsi,4)
movups 0x20(%r13,%rsi,4),%xmm0
movups 0x30(%r13,%rsi,4),%xmm1
movups %xmm0,0x20(%r14,%rsi,4)
movups %xmm1,0x30(%r14,%rsi,4)
movups 0x40(%r13,%rsi,4),%xmm0
movups 0x50(%r13,%rsi,4),%xmm1
movups %xmm0,0x40(%r14,%rsi,4)
movups %xmm1,0x50(%r14,%rsi,4)
movups 0x60(%r13,%rsi,4),%xmm0
movups 0x70(%r13,%rsi,4),%xmm1
movups %xmm0,0x60(%r14,%rsi,4)
movups %xmm1,0x70(%r14,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdx
jne    13c0 <morsi_all+0x280>
test   %rcx,%rcx
je     146b <morsi_all+0x32b>
lea    (%r14,%rsi,4),%rdx
add    $0x10,%rdx
lea    0x10(,%rsi,4),%rsi
add    %r13,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups -0x10(%rsi,%rdi,1),%xmm0
movups (%rsi,%rdi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rdi,1)
movups %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    1450 <morsi_all+0x310>
cmp    %r11,%rax
jne    12fa <morsi_all+0x1ba>
test   %r12,%r12
mov    0x60(%rsp),%r14
mov    0x28(%rsp),%r10
mov    0x40(%rsp),%r9
mov    (%rsp),%rsi
mov    0x70(%rsp),%rbp
je     1628 <morsi_all+0x4e8>
test   %r8d,%r8d
jle    1628 <morsi_all+0x4e8>
cmp    $0x8,%r8d
jb     14ba <morsi_all+0x37a>
lea    (%r15,%r11,4),%rax
cmp    %r12,%rax
jbe    1534 <morsi_all+0x3f4>
lea    (%r12,%r11,4),%rax
cmp    %rax,%r15
jae    1534 <morsi_all+0x3f4>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r11,%rcx
mov    %r11,%rdx
and    $0x3,%rdx
je     14e6 <morsi_all+0x3a6>
xchg   %ax,%ax
movss  (%r15,%rax,4),%xmm0
movss  %xmm0,(%r12,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    14d0 <morsi_all+0x390>
cmp    $0x3,%rcx
jb     1628 <morsi_all+0x4e8>
movss  (%r15,%rax,4),%xmm0
movss  %xmm0,(%r12,%rax,4)
movss  0x4(%r15,%rax,4),%xmm0
movss  %xmm0,0x4(%r12,%rax,4)
movss  0x8(%r15,%rax,4),%xmm0
movss  %xmm0,0x8(%r12,%rax,4)
movss  0xc(%r15,%rax,4),%xmm0
movss  %xmm0,0xc(%r12,%rax,4)
add    $0x4,%rax
cmp    %rax,%r11
jne    14f0 <morsi_all+0x3b0>
jmp    1628 <morsi_all+0x4e8>
mov    %r11d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    155b <morsi_all+0x41b>
xor    %esi,%esi
jmp    15d8 <morsi_all+0x498>
movabs $0x3ffffffffffffffe,%rsi
ff ff 3f
add    $0xfffffffffffffffe,%rsi
and    %rsi,%rdx
xor    %esi,%esi
xchg   %ax,%ax
movups (%r15,%rsi,4),%xmm0
movups 0x10(%r15,%rsi,4),%xmm1
movups %xmm0,(%r12,%rsi,4)
movups %xmm1,0x10(%r12,%rsi,4)
movups 0x20(%r15,%rsi,4),%xmm0
movups 0x30(%r15,%rsi,4),%xmm1
movups %xmm0,0x20(%r12,%rsi,4)
movups %xmm1,0x30(%r12,%rsi,4)
movups 0x40(%r15,%rsi,4),%xmm0
movups 0x50(%r15,%rsi,4),%xmm1
movups %xmm0,0x40(%r12,%rsi,4)
movups %xmm1,0x50(%r12,%rsi,4)
movups 0x60(%r15,%rsi,4),%xmm0
movups 0x70(%r15,%rsi,4),%xmm1
movups %xmm0,0x60(%r12,%rsi,4)
movups %xmm1,0x70(%r12,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1570 <morsi_all+0x430>
test   %rcx,%rcx
je     161b <morsi_all+0x4db>
lea    (%r12,%rsi,4),%rdx
add    $0x10,%rdx
lea    (%r15,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rsi,%rdi,1),%xmm0
movups (%rsi,%rdi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rdi,1)
movups %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    1600 <morsi_all+0x4c0>
cmp    %r11,%rax
mov    (%rsp),%rsi
jne    14bc <morsi_all+0x37c>
mov    0x50(%rsp),%r12
test   %r12,%r12
mov    %r11,0x68(%rsp)
je     1667 <morsi_all+0x527>
mov    %r12,%rdi
mov    %r13,%rsi
mov    0x20(%rsp),%edx
mov    0x24(%rsp),%ecx
mov    0x48(%rsp),%r8
call   1040 <morsi_dilation@plt>
mov    (%rsp),%rsi
mov    0x40(%rsp),%r9
mov    0x18(%rsp),%r8
mov    0x68(%rsp),%r11
mov    0x28(%rsp),%r10
test   %r14,%r14
je     169c <morsi_all+0x55c>
mov    %r14,%rdi
mov    %r15,%rsi
mov    0x20(%rsp),%edx
mov    0x24(%rsp),%ecx
mov    0x48(%rsp),%r8
call   1060 <morsi_erosion@plt>
mov    (%rsp),%rsi
mov    0x40(%rsp),%r9
mov    0x18(%rsp),%r8
mov    0x68(%rsp),%r11
mov    0x28(%rsp),%r10
test   %rbp,%rbp
mov    0x10(%rsp),%rdi
je     1888 <morsi_all+0x748>
test   %r8d,%r8d
jle    1888 <morsi_all+0x748>
cmp    $0x8,%r8d
jae    16c0 <morsi_all+0x580>
xor    %eax,%eax
jmp    17e1 <morsi_all+0x6a1>
lea    0x0(,%r11,4),%rax
add    %rbp,%rax
lea    (%r15,%r11,4),%rcx
lea    0x0(,%r11,4),%rdx
add    %r13,%rdx
cmp    %rbp,%rcx
seta   %sil
cmp    %rax,%r15
setb   %dil
cmp    %rbp,%rdx
seta   %cl
cmp    %rax,%r13
setb   %dl
xor    %eax,%eax
test   %dil,%sil
jne    179b <morsi_all+0x65b>
and    %dl,%cl
mov    0x10(%rsp),%rdi
mov    (%rsp),%rsi
jne    17e1 <morsi_all+0x6a1>
mov    %r11d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     17a6 <morsi_all+0x666>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%r15,%rcx,4),%xmm0
movups 0x10(%r15,%rcx,4),%xmm1
movups 0x0(%r13,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x10(%r13,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,0x0(%rbp,%rcx,4)
movups %xmm1,0x10(%rbp,%rcx,4)
movups 0x20(%r15,%rcx,4),%xmm0
movups 0x30(%r15,%rcx,4),%xmm1
movups 0x20(%r13,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x30(%r13,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,0x20(%rbp,%rcx,4)
movups %xmm1,0x30(%rbp,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1740 <morsi_all+0x600>
jmp    17a8 <morsi_all+0x668>
mov    0x10(%rsp),%rdi
mov    (%rsp),%rsi
jmp    17e1 <morsi_all+0x6a1>
xor    %ecx,%ecx
test   $0x1,%dl
mov    (%rsp),%rsi
je     17d8 <morsi_all+0x698>
movups (%r15,%rcx,4),%xmm0
movups 0x10(%r15,%rcx,4),%xmm1
movups 0x0(%r13,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x10(%r13,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,0x0(%rbp,%rcx,4)
movups %xmm1,0x10(%rbp,%rcx,4)
cmp    %r11,%rax
je     1888 <morsi_all+0x748>
mov    %rax,%rcx
not    %rcx
add    %r11,%rcx
mov    %r11,%rdx
and    $0x3,%rdx
je     181d <morsi_all+0x6dd>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%r15,%rax,4),%xmm0
subss  0x0(%r13,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1800 <morsi_all+0x6c0>
cmp    $0x3,%rcx
jb     1888 <morsi_all+0x748>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%r15,%rax,4),%xmm0
subss  0x0(%r13,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
movss  0x4(%r15,%rax,4),%xmm0
subss  0x4(%r13,%rax,4),%xmm0
movss  %xmm0,0x4(%rbp,%rax,4)
movss  0x8(%r15,%rax,4),%xmm0
subss  0x8(%r13,%rax,4),%xmm0
movss  %xmm0,0x8(%rbp,%rax,4)
movss  0xc(%r15,%rax,4),%xmm0
subss  0xc(%r13,%rax,4),%xmm0
movss  %xmm0,0xc(%rbp,%rax,4)
add    $0x4,%rax
cmp    %rax,%r11
jne    1830 <morsi_all+0x6f0>
mov    0x30(%rsp),%rcx
test   %rcx,%rcx
mov    0x58(%rsp),%rbp
je     1a73 <morsi_all+0x933>
test   %r8d,%r8d
jle    1a73 <morsi_all+0x933>
cmp    $0x8,%r8d
jae    18b1 <morsi_all+0x771>
xor    %eax,%eax
jmp    19d0 <morsi_all+0x890>
lea    (%rbx,%r11,4),%rax
cmp    %rcx,%rax
seta   %dil
lea    (%rcx,%r11,4),%rax
cmp    %rbx,%rax
mov    %rcx,%rsi
seta   %dl
lea    0x0(,%r11,4),%rcx
add    %r13,%rcx
cmp    %rsi,%rcx
seta   %cl
cmp    %rax,%r13
setb   %sil
xor    %eax,%eax
test   %dl,%dil
jne    1986 <morsi_all+0x846>
and    %sil,%cl
mov    0x10(%rsp),%rdi
mov    (%rsp),%rsi
jne    19d0 <morsi_all+0x890>
mov    %r11d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
mov    %rdx,0x28(%rsp)
je     1991 <morsi_all+0x851>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
mov    0x30(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
movups (%rbx,%rcx,4),%xmm0
movups 0x10(%rbx,%rcx,4),%xmm1
movups 0x0(%r13,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x10(%r13,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,(%rdx,%rcx,4)
movups %xmm1,0x10(%rdx,%rcx,4)
movups 0x20(%rbx,%rcx,4),%xmm0
movups 0x30(%rbx,%rcx,4),%xmm1
movups 0x20(%r13,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x30(%r13,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,0x20(%rdx,%rcx,4)
movups %xmm1,0x30(%rdx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1930 <morsi_all+0x7f0>
jmp    1998 <morsi_all+0x858>
mov    0x10(%rsp),%rdi
mov    (%rsp),%rsi
jmp    19d0 <morsi_all+0x890>
xor    %ecx,%ecx
mov    0x30(%rsp),%rdx
testb  $0x1,0x28(%rsp)
mov    (%rsp),%rsi
je     19c7 <morsi_all+0x887>
movups (%rbx,%rcx,4),%xmm0
movups 0x10(%rbx,%rcx,4),%xmm1
movups 0x0(%r13,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x10(%r13,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,(%rdx,%rcx,4)
movups %xmm1,0x10(%rdx,%rcx,4)
cmp    %r11,%rax
je     1a73 <morsi_all+0x933>
mov    %rax,%r8
not    %r8
add    %r11,%r8
mov    %r11,%rdx
and    $0x3,%rdx
je     1a0d <morsi_all+0x8cd>
mov    0x30(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movss  (%rbx,%rax,4),%xmm0
subss  0x0(%r13,%rax,4),%xmm0
movss  %xmm0,(%rcx,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    19f0 <morsi_all+0x8b0>
jmp    1a12 <morsi_all+0x8d2>
mov    0x30(%rsp),%rcx
cmp    $0x3,%r8
mov    0x18(%rsp),%r8
jb     1a73 <morsi_all+0x933>
nopl   (%rax)
movss  (%rbx,%rax,4),%xmm0
subss  0x0(%r13,%rax,4),%xmm0
movss  %xmm0,(%rcx,%rax,4)
movss  0x4(%rbx,%rax,4),%xmm0
subss  0x4(%r13,%rax,4),%xmm0
movss  %xmm0,0x4(%rcx,%rax,4)
movss  0x8(%rbx,%rax,4),%xmm0
subss  0x8(%r13,%rax,4),%xmm0
movss  %xmm0,0x8(%rcx,%rax,4)
movss  0xc(%rbx,%rax,4),%xmm0
subss  0xc(%r13,%rax,4),%xmm0
movss  %xmm0,0xc(%rcx,%rax,4)
add    $0x4,%rax
cmp    %rax,%r11
jne    1a20 <morsi_all+0x8e0>
mov    0x38(%rsp),%rdx
test   %rdx,%rdx
je     1c52 <morsi_all+0xb12>
test   %r8d,%r8d
jle    1c52 <morsi_all+0xb12>
cmp    $0x8,%r8d
jae    1a97 <morsi_all+0x957>
xor    %eax,%eax
jmp    1bb7 <morsi_all+0xa77>
lea    (%rdx,%r11,4),%rax
lea    (%r15,%r11,4),%rcx
lea    (%rbx,%r11,4),%rsi
cmp    %rdx,%rcx
seta   %r8b
cmp    %rax,%r15
setb   %dil
cmp    %rdx,%rsi
seta   %cl
cmp    %rbx,%rax
seta   %dl
xor    %eax,%eax
test   %dil,%r8b
jne    1b69 <morsi_all+0xa29>
and    %dl,%cl
mov    0x10(%rsp),%rdi
mov    (%rsp),%rsi
jne    1bb7 <morsi_all+0xa77>
mov    %r11d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1b74 <morsi_all+0xa34>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
mov    0x38(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
nop
movups (%r15,%rcx,4),%xmm0
movups 0x10(%r15,%rcx,4),%xmm1
movups (%rbx,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x10(%rbx,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,(%r8,%rcx,4)
movups %xmm1,0x10(%r8,%rcx,4)
movups 0x20(%r15,%rcx,4),%xmm0
movups 0x30(%r15,%rcx,4),%xmm1
movups 0x20(%rbx,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x30(%rbx,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,0x20(%r8,%rcx,4)
movups %xmm1,0x30(%r8,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1b10 <morsi_all+0x9d0>
jmp    1b7b <morsi_all+0xa3b>
mov    0x10(%rsp),%rdi
mov    (%rsp),%rsi
jmp    1bb7 <morsi_all+0xa77>
xor    %ecx,%ecx
mov    0x38(%rsp),%r8
test   $0x1,%dl
mov    (%rsp),%rsi
je     1ba9 <morsi_all+0xa69>
movups (%r15,%rcx,4),%xmm0
movups 0x10(%r15,%rcx,4),%xmm1
movups (%rbx,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x10(%rbx,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,(%r8,%rcx,4)
movups %xmm1,0x10(%r8,%rcx,4)
cmp    %r11,%rax
mov    0x18(%rsp),%r8
je     1c52 <morsi_all+0xb12>
mov    %rax,%r8
not    %r8
add    %r11,%r8
mov    %r11,%rdx
and    $0x3,%rdx
je     1bec <morsi_all+0xaac>
mov    0x38(%rsp),%rcx
xchg   %ax,%ax
movss  (%r15,%rax,4),%xmm0
subss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rcx,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1bd0 <morsi_all+0xa90>
jmp    1bf1 <morsi_all+0xab1>
mov    0x38(%rsp),%rcx
cmp    $0x3,%r8
mov    0x18(%rsp),%r8
jb     1c52 <morsi_all+0xb12>
nopl   0x0(%rax)
movss  (%r15,%rax,4),%xmm0
subss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rcx,%rax,4)
movss  0x4(%r15,%rax,4),%xmm0
subss  0x4(%rbx,%rax,4),%xmm0
movss  %xmm0,0x4(%rcx,%rax,4)
movss  0x8(%r15,%rax,4),%xmm0
subss  0x8(%rbx,%rax,4),%xmm0
movss  %xmm0,0x8(%rcx,%rax,4)
movss  0xc(%r15,%rax,4),%xmm0
subss  0xc(%rbx,%rax,4),%xmm0
movss  %xmm0,0xc(%rcx,%rax,4)
add    $0x4,%rax
cmp    %rax,%r11
jne    1c00 <morsi_all+0xac0>
test   %rsi,%rsi
je     1e12 <morsi_all+0xcd2>
test   %r8d,%r8d
jle    1e12 <morsi_all+0xcd2>
cmp    $0x8,%r8d
jae    1c71 <morsi_all+0xb31>
xor    %eax,%eax
jmp    1d83 <morsi_all+0xc43>
lea    (%rbx,%r11,4),%rax
cmp    %rsi,%rax
seta   %dil
lea    (%rsi,%r11,4),%rax
cmp    %rbx,%rax
seta   %dl
lea    (%r12,%r11,4),%rcx
cmp    %rsi,%rcx
seta   %cl
cmp    %rax,%r12
setb   %sil
xor    %eax,%eax
test   %dl,%dil
jne    1d39 <morsi_all+0xbf9>
and    %sil,%cl
mov    0x10(%rsp),%rdi
mov    (%rsp),%rsi
jne    1d83 <morsi_all+0xc43>
mov    %r11d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1d44 <morsi_all+0xc04>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
mov    (%rsp),%r8
nopl   0x0(%rax,%rax,1)
movups (%rbx,%rcx,4),%xmm0
movups 0x10(%rbx,%rcx,4),%xmm1
movups (%r12,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x10(%r12,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,(%r8,%rcx,4)
movups %xmm1,0x10(%r8,%rcx,4)
movups 0x20(%rbx,%rcx,4),%xmm0
movups 0x30(%rbx,%rcx,4),%xmm1
movups 0x20(%r12,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x30(%r12,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,0x20(%r8,%rcx,4)
movups %xmm1,0x30(%r8,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1ce0 <morsi_all+0xba0>
jmp    1d4a <morsi_all+0xc0a>
mov    0x10(%rsp),%rdi
mov    (%rsp),%rsi
jmp    1d83 <morsi_all+0xc43>
xor    %ecx,%ecx
mov    (%rsp),%r8
test   $0x1,%dl
mov    %r8,%rsi
je     1d75 <morsi_all+0xc35>
movups (%rbx,%rcx,4),%xmm0
movups 0x10(%rbx,%rcx,4),%xmm1
movups (%r12,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x10(%r12,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,(%rsi,%rcx,4)
movups %xmm1,0x10(%rsi,%rcx,4)
cmp    %r11,%rax
mov    0x18(%rsp),%r8
je     1e12 <morsi_all+0xcd2>
mov    %rax,%rcx
not    %rcx
add    %r11,%rcx
mov    %r11,%rdx
and    $0x3,%rdx
je     1dba <morsi_all+0xc7a>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rbx,%rax,4),%xmm0
subss  (%r12,%rax,4),%xmm0
movss  %xmm0,(%rsi,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1da0 <morsi_all+0xc60>
cmp    $0x3,%rcx
jb     1e12 <morsi_all+0xcd2>
movss  (%rbx,%rax,4),%xmm0
subss  (%r12,%rax,4),%xmm0
movss  %xmm0,(%rsi,%rax,4)
movss  0x4(%rbx,%rax,4),%xmm0
subss  0x4(%r12,%rax,4),%xmm0
movss  %xmm0,0x4(%rsi,%rax,4)
movss  0x8(%rbx,%rax,4),%xmm0
subss  0x8(%r12,%rax,4),%xmm0
movss  %xmm0,0x8(%rsi,%rax,4)
movss  0xc(%rbx,%rax,4),%xmm0
subss  0xc(%r12,%rax,4),%xmm0
movss  %xmm0,0xc(%rsi,%rax,4)
add    $0x4,%rax
cmp    %rax,%r11
jne    1dc0 <morsi_all+0xc80>
test   %rdi,%rdi
je     1fb2 <morsi_all+0xe72>
test   %r8d,%r8d
jle    1fb2 <morsi_all+0xe72>
cmp    $0x8,%r8d
jae    1e31 <morsi_all+0xcf1>
xor    %eax,%eax
jmp    1f2a <morsi_all+0xdea>
lea    (%rdi,%r11,4),%rax
lea    (%r14,%r11,4),%rcx
lea    (%rbx,%r11,4),%rdx
cmp    %rdi,%rcx
seta   %sil
cmp    %rax,%r14
mov    %rdi,%rcx
setb   %dil
cmp    %rcx,%rdx
seta   %cl
cmp    %rbx,%rax
seta   %dl
xor    %eax,%eax
test   %dil,%sil
jne    1f25 <morsi_all+0xde5>
and    %dl,%cl
mov    0x10(%rsp),%rdi
jne    1f2a <morsi_all+0xdea>
mov    %r11d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     251b <morsi_all+0x13db>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopl   0x0(%rax)
movups (%r14,%rcx,4),%xmm0
movups 0x10(%r14,%rcx,4),%xmm1
movups (%rbx,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x10(%rbx,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,(%rdi,%rcx,4)
movups %xmm1,0x10(%rdi,%rcx,4)
movups 0x20(%r14,%rcx,4),%xmm0
movups 0x30(%r14,%rcx,4),%xmm1
movups 0x20(%rbx,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x30(%rbx,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,0x20(%rdi,%rcx,4)
movups %xmm1,0x30(%rdi,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1ea0 <morsi_all+0xd60>
test   $0x1,%dl
je     1f1b <morsi_all+0xddb>
movups (%r14,%rcx,4),%xmm0
movups 0x10(%r14,%rcx,4),%xmm1
movups (%rbx,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x10(%rbx,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,(%rdi,%rcx,4)
movups %xmm1,0x10(%rdi,%rcx,4)
cmp    %r11,%rax
jne    1f2a <morsi_all+0xdea>
jmp    1fb2 <morsi_all+0xe72>
mov    0x10(%rsp),%rdi
mov    %rax,%rcx
not    %rcx
add    %r11,%rcx
mov    %r11,%rdx
and    $0x3,%rdx
je     1f5a <morsi_all+0xe1a>
nopl   0x0(%rax)
movss  (%r14,%rax,4),%xmm0
subss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rdi,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1f40 <morsi_all+0xe00>
cmp    $0x3,%rcx
jb     1fb2 <morsi_all+0xe72>
movss  (%r14,%rax,4),%xmm0
subss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rdi,%rax,4)
movss  0x4(%r14,%rax,4),%xmm0
subss  0x4(%rbx,%rax,4),%xmm0
movss  %xmm0,0x4(%rdi,%rax,4)
movss  0x8(%r14,%rax,4),%xmm0
subss  0x8(%rbx,%rax,4),%xmm0
movss  %xmm0,0x8(%rdi,%rax,4)
movss  0xc(%r14,%rax,4),%xmm0
subss  0xc(%rbx,%rax,4),%xmm0
movss  %xmm0,0xc(%rdi,%rax,4)
add    $0x4,%rax
cmp    %rax,%r11
jne    1f60 <morsi_all+0xe20>
test   %r9,%r9
je     217a <morsi_all+0x103a>
test   %r8d,%r8d
jle    217a <morsi_all+0x103a>
cmp    $0x8,%r8d
jae    1fd1 <morsi_all+0xe91>
xor    %eax,%eax
jmp    20d0 <morsi_all+0xf90>
lea    (%r9,%r11,4),%rax
lea    (%r14,%r11,4),%rcx
lea    (%r12,%r11,4),%rdx
cmp    %r9,%rcx
seta   %sil
cmp    %rax,%r14
setb   %dil
cmp    %r9,%rdx
seta   %cl
cmp    %rax,%r12
setb   %dl
xor    %eax,%eax
test   %dil,%sil
jne    20d0 <morsi_all+0xf90>
and    %dl,%cl
jne    20d0 <morsi_all+0xf90>
mov    %r11d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     252b <morsi_all+0x13eb>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%r14,%rcx,4),%xmm0
movups 0x10(%r14,%rcx,4),%xmm1
movups (%r12,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x10(%r12,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,(%r9,%rcx,4)
movups %xmm1,0x10(%r9,%rcx,4)
movups 0x20(%r14,%rcx,4),%xmm0
movups 0x30(%r14,%rcx,4),%xmm1
movups 0x20(%r12,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x30(%r12,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,0x20(%r9,%rcx,4)
movups %xmm1,0x30(%r9,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    2040 <morsi_all+0xf00>
test   $0x1,%dl
je     20c7 <morsi_all+0xf87>
movups (%r14,%rcx,4),%xmm0
movups 0x10(%r14,%rcx,4),%xmm1
movups (%r12,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x10(%r12,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,(%r9,%rcx,4)
movups %xmm1,0x10(%r9,%rcx,4)
cmp    %r11,%rax
je     217a <morsi_all+0x103a>
mov    %rax,%rcx
not    %rcx
add    %r11,%rcx
mov    %r11,%rdx
and    $0x3,%rdx
je     210c <morsi_all+0xfcc>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%r14,%rax,4),%xmm0
subss  (%r12,%rax,4),%xmm0
movss  %xmm0,(%r9,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    20f0 <morsi_all+0xfb0>
cmp    $0x3,%rcx
jb     217a <morsi_all+0x103a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%r14,%rax,4),%xmm0
subss  (%r12,%rax,4),%xmm0
movss  %xmm0,(%r9,%rax,4)
movss  0x4(%r14,%rax,4),%xmm0
subss  0x4(%r12,%rax,4),%xmm0
movss  %xmm0,0x4(%r9,%rax,4)
movss  0x8(%r14,%rax,4),%xmm0
subss  0x8(%r12,%rax,4),%xmm0
movss  %xmm0,0x8(%r9,%rax,4)
movss  0xc(%r14,%rax,4),%xmm0
subss  0xc(%r12,%rax,4),%xmm0
movss  %xmm0,0xc(%r9,%rax,4)
add    $0x4,%rax
cmp    %rax,%r11
jne    2120 <morsi_all+0xfe0>
test   %rbp,%rbp
je     2303 <morsi_all+0x11c3>
test   %r8d,%r8d
jle    2303 <morsi_all+0x11c3>
cmp    $0x8,%r8d
jae    2199 <morsi_all+0x1059>
xor    %eax,%eax
jmp    226a <morsi_all+0x112a>
lea    0x0(,%r11,4),%rax
add    %rbp,%rax
lea    (%r15,%r11,4),%rcx
lea    0x0(,%r11,4),%rdx
add    %r13,%rdx
lea    (%rbx,%r11,4),%rdi
cmp    %rcx,%rbp
setb   %r8b
cmp    %rax,%r15
setb   %r9b
cmp    %rdx,%rbp
setb   %cl
cmp    %rax,%r13
setb   %sil
cmp    %rdi,%rbp
setb   %dl
cmp    %rbx,%rax
seta   %dil
xor    %eax,%eax
test   %r9b,%r8b
jne    2265 <morsi_all+0x1125>
and    %sil,%cl
jne    2265 <morsi_all+0x1125>
and    %dil,%dl
mov    0x18(%rsp),%r8
jne    226a <morsi_all+0x112a>
mov    %r11d,%eax
and    $0xfffffff8,%eax
xor    %ecx,%ecx
movaps 0xdfc(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%r15,%rcx,4),%xmm1
movups 0x10(%r15,%rcx,4),%xmm2
movups 0x0(%r13,%rcx,4),%xmm3
addps  %xmm1,%xmm3
movups 0x10(%r13,%rcx,4),%xmm1
addps  %xmm2,%xmm1
movups (%rbx,%rcx,4),%xmm2
movups 0x10(%rbx,%rcx,4),%xmm4
addps  %xmm2,%xmm2
subps  %xmm2,%xmm3
addps  %xmm4,%xmm4
subps  %xmm4,%xmm1
mulps  %xmm0,%xmm3
mulps  %xmm0,%xmm1
movups %xmm3,0x0(%rbp,%rcx,4)
movups %xmm1,0x10(%rbp,%rcx,4)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    2210 <morsi_all+0x10d0>
cmp    %r11,%rax
jne    226a <morsi_all+0x112a>
jmp    2303 <morsi_all+0x11c3>
mov    0x18(%rsp),%r8
mov    %rax,%rcx
not    %rcx
test   $0x1,%r11b
je     22a2 <morsi_all+0x1162>
movss  (%r15,%rax,4),%xmm0
addss  0x0(%r13,%rax,4),%xmm0
movss  (%rbx,%rax,4),%xmm1
addss  %xmm1,%xmm1
subss  %xmm1,%xmm0
mulss  0xd78(%rip),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
or     $0x1,%rax
add    %r11,%rcx
je     2303 <morsi_all+0x11c3>
movss  0xd61(%rip),%xmm0
nop
movss  (%r15,%rax,4),%xmm1
addss  0x0(%r13,%rax,4),%xmm1
movss  (%rbx,%rax,4),%xmm2
addss  %xmm2,%xmm2
subss  %xmm2,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x0(%rbp,%rax,4)
movss  0x4(%r15,%rax,4),%xmm1
addss  0x4(%r13,%rax,4),%xmm1
movss  0x4(%rbx,%rax,4),%xmm2
addss  %xmm2,%xmm2
subss  %xmm2,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%rbp,%rax,4)
add    $0x2,%rax
cmp    %rax,%r11
jne    22b0 <morsi_all+0x1170>
test   %r10,%r10
je     24b3 <morsi_all+0x1373>
test   %r8d,%r8d
jle    24b3 <morsi_all+0x1373>
cmp    $0x8,%r8d
jae    2322 <morsi_all+0x11e2>
xor    %eax,%eax
jmp    2416 <morsi_all+0x12d6>
lea    (%rbx,%r11,4),%rax
cmp    %r10,%rax
seta   %dil
lea    (%r10,%r11,4),%rax
cmp    %rbx,%rax
seta   %dl
lea    0x0(,%r11,4),%rcx
add    %rbp,%rcx
cmp    %r10,%rcx
seta   %cl
cmp    %rax,%rbp
setb   %sil
xor    %eax,%eax
test   %dl,%dil
jne    2416 <morsi_all+0x12d6>
and    %sil,%cl
jne    2416 <morsi_all+0x12d6>
mov    %r11d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     253b <morsi_all+0x13fb>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movups (%rbx,%rcx,4),%xmm0
movups 0x10(%rbx,%rcx,4),%xmm1
movups 0x0(%rbp,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x10(%rbp,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,(%r10,%rcx,4)
movups %xmm1,0x10(%r10,%rcx,4)
movups 0x20(%rbx,%rcx,4),%xmm0
movups 0x30(%rbx,%rcx,4),%xmm1
movups 0x20(%rbp,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x30(%rbp,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,0x20(%r10,%rcx,4)
movups %xmm1,0x30(%r10,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    2390 <morsi_all+0x1250>
test   $0x1,%dl
je     240d <morsi_all+0x12cd>
movups (%rbx,%rcx,4),%xmm0
movups 0x10(%rbx,%rcx,4),%xmm1
movups 0x0(%rbp,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x10(%rbp,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,(%r10,%rcx,4)
movups %xmm1,0x10(%r10,%rcx,4)
cmp    %r11,%rax
je     24b3 <morsi_all+0x1373>
mov    %rax,%rcx
not    %rcx
add    %r11,%rcx
mov    %r11,%rdx
and    $0x3,%rdx
je     244b <morsi_all+0x130b>
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rax,4),%xmm0
subss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,(%r10,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    2430 <morsi_all+0x12f0>
cmp    $0x3,%rcx
jb     24b3 <morsi_all+0x1373>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rax,4),%xmm0
subss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,(%r10,%rax,4)
movss  0x4(%rbx,%rax,4),%xmm0
subss  0x4(%rbp,%rax,4),%xmm0
movss  %xmm0,0x4(%r10,%rax,4)
movss  0x8(%rbx,%rax,4),%xmm0
subss  0x8(%rbp,%rax,4),%xmm0
movss  %xmm0,0x8(%r10,%rax,4)
movss  0xc(%rbx,%rax,4),%xmm0
subss  0xc(%rbp,%rax,4),%xmm0
movss  %xmm0,0xc(%r10,%rax,4)
add    $0x4,%rax
cmp    %rax,%r11
jne    2460 <morsi_all+0x1320>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
cmpb   $0x0,0xf(%rsp)
je     24ef <morsi_all+0x13af>
mov    %r12,%rdi
call   1030 <free@plt>
cmpb   $0x0,0xe(%rsp)
jne    24f6 <morsi_all+0x13b6>
cmpb   $0x0,0xd(%rsp)
je     2505 <morsi_all+0x13c5>
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmpb   $0x0,0xe(%rsp)
je     24d9 <morsi_all+0x1399>
mov    %r14,%rdi
call   1030 <free@plt>
cmpb   $0x0,0xd(%rsp)
jne    24e0 <morsi_all+0x13a0>
mov    %rbp,%rdi
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
xor    %ecx,%ecx
test   $0x1,%dl
jne    1ef8 <morsi_all+0xdb8>
jmp    1f1b <morsi_all+0xddb>
xor    %ecx,%ecx
test   $0x1,%dl
jne    20a0 <morsi_all+0xf60>
jmp    20c7 <morsi_all+0xf87>
xor    %ecx,%ecx
test   $0x1,%dl
jne    23e9 <morsi_all+0x12a9>
jmp    240d <morsi_all+0x12cd>

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

LLVM IR (-O2):
define void @morsi_all(float* writeonly %0, float* writeonly %1, float* %2, float* %3, float* writeonly %4, float* writeonly %5, float* writeonly %6, float* %7, float* writeonly %8, float* writeonly %9, float* writeonly %10, float* writeonly %11, float* %12, i32 %13, i32 %14, i32* %15) {
%17 = mul nsw i32 %14, %13
%18 = shl i32 %17, 2
%19 = tail call float* @xmalloc(i32 %18)
%20 = tail call float* @xmalloc(i32 %18)
%21 = icmp ne float* %10, null
%22 = icmp ne float* %9, null
%23 = or i1 %22, %21
%24 = icmp eq float* %2, null
%25 = and i1 %24, %23
br i1 %25, label %26, label %28
26: ; preds = %16
%27 = tail call float* @xmalloc(i32 %18)
br label %28
28: ; preds = %16, %26
%29 = phi float* [ %2, %16 ], [ %27, %26 ]
%30 = icmp ne float* %11, null
%31 = or i1 %22, %30
%32 = icmp eq float* %3, null
%33 = and i1 %32, %31
br i1 %33, label %34, label %36
34: ; preds = %28
%35 = tail call float* @xmalloc(i32 %18)
br label %36
36: ; preds = %28, %34
%37 = phi float* [ %3, %28 ], [ %35, %34 ]
%38 = icmp eq float* %8, null
%39 = icmp ne float* %7, null
%40 = or i1 %39, %38
br i1 %40, label %43, label %41
41: ; preds = %36
%42 = tail call float* @xmalloc(i32 %18)
br label %43
43: ; preds = %41, %36
%44 = phi float* [ %7, %36 ], [ %42, %41 ]
%45 = tail call i32 @morsi_erosion(float* %19, float* %12, i32 %13, i32 %14, i32* %15)
%46 = tail call i32 @morsi_dilation(float* %20, float* %12, i32 %13, i32 %14, i32* %15)
%47 = icmp ne float* %0, null
%48 = icmp sgt i32 %17, 0
%49 = select i1 %47, i1 %48, i1 false
br i1 %49, label %50, label %175
50: ; preds = %43
%51 = zext i32 %17 to i64
%52 = icmp ult i32 %17, 8
br i1 %52, label %138, label %53
53: ; preds = %50
%54 = getelementptr float, float* %0, i64 %51
%55 = getelementptr float, float* %19, i64 %51
%56 = icmp ugt float* %55, %0
%57 = icmp ult float* %19, %54
%58 = and i1 %56, %57
br i1 %58, label %138, label %59
59: ; preds = %53
%60 = and i64 %51, 4294967288
%61 = add nsw i64 %60, -8
%62 = lshr exact i64 %61, 3
%63 = add nuw nsw i64 %62, 1
%64 = and i64 %63, 3
%65 = icmp ult i64 %61, 24
br i1 %65, label %117, label %66
66: ; preds = %59
%67 = and i64 %63, 4611686018427387900
br label %68
68: ; preds = %68, %66
%69 = phi i64 [ 0, %66 ], [ %114, %68 ]
%70 = phi i64 [ 0, %66 ], [ %115, %68 ]
%71 = getelementptr inbounds float, float* %19, i64 %69
%72 = bitcast float* %71 to <4 x float>*
%73 = load <4 x float>, <4 x float>* %72
%74 = getelementptr inbounds float, float* %71, i64 4
%75 = bitcast float* %74 to <4 x float>*
%76 = load <4 x float>, <4 x float>* %75
%77 = getelementptr inbounds float, float* %0, i64 %69
%78 = bitcast float* %77 to <4 x float>*
store <4 x float> %73, <4 x float>* %78
%79 = getelementptr inbounds float, float* %77, i64 4
%80 = bitcast float* %79 to <4 x float>*
store <4 x float> %76, <4 x float>* %80
%81 = or i64 %69, 8
%82 = getelementptr inbounds float, float* %19, i64 %81
%83 = bitcast float* %82 to <4 x float>*
%84 = load <4 x float>, <4 x float>* %83
%85 = getelementptr inbounds float, float* %82, i64 4
%86 = bitcast float* %85 to <4 x float>*
%87 = load <4 x float>, <4 x float>* %86
%88 = getelementptr inbounds float, float* %0, i64 %81
%89 = bitcast float* %88 to <4 x float>*
store <4 x float> %84, <4 x float>* %89
%90 = getelementptr inbounds float, float* %88, i64 4
%91 = bitcast float* %90 to <4 x float>*
store <4 x float> %87, <4 x float>* %91
%92 = or i64 %69, 16
%93 = getelementptr inbounds float, float* %19, i64 %92
%94 = bitcast float* %93 to <4 x float>*
%95 = load <4 x float>, <4 x float>* %94
%96 = getelementptr inbounds float, float* %93, i64 4
%97 = bitcast float* %96 to <4 x float>*
%98 = load <4 x float>, <4 x float>* %97
%99 = getelementptr inbounds float, float* %0, i64 %92
%100 = bitcast float* %99 to <4 x float>*
store <4 x float> %95, <4 x float>* %100
%101 = getelementptr inbounds float, float* %99, i64 4
%102 = bitcast float* %101 to <4 x float>*
store <4 x float> %98, <4 x float>* %102
%103 = or i64 %69, 24
%104 = getelementptr inbounds float, float* %19, i64 %103
%105 = bitcast float* %104 to <4 x float>*
%106 = load <4 x float>, <4 x float>* %105
%107 = getelementptr inbounds float, float* %104, i64 4
%108 = bitcast float* %107 to <4 x float>*
%109 = load <4 x float>, <4 x float>* %108
%110 = getelementptr inbounds float, float* %0, i64 %103
%111 = bitcast float* %110 to <4 x float>*
store <4 x float> %106, <4 x float>* %111
%112 = getelementptr inbounds float, float* %110, i64 4
%113 = bitcast float* %112 to <4 x float>*
store <4 x float> %109, <4 x float>* %113
%114 = add nuw i64 %69, 32
%115 = add i64 %70, 4
%116 = icmp eq i64 %115, %67
br i1 %116, label %117, label %68
117: ; preds = %68, %59
%118 = phi i64 [ 0, %59 ], [ %114, %68 ]
%119 = icmp eq i64 %64, 0
br i1 %119, label %136, label %120
120: ; preds = %117, %120
%121 = phi i64 [ %133, %120 ], [ %118, %117 ]
%122 = phi i64 [ %134, %120 ], [ 0, %117 ]
%123 = getelementptr inbounds float, float* %19, i64 %121
%124 = bitcast float* %123 to <4 x float>*
%125 = load <4 x float>, <4 x float>* %124
%126 = getelementptr inbounds float, float* %123, i64 4
%127 = bitcast float* %126 to <4 x float>*
%128 = load <4 x float>, <4 x float>* %127
%129 = getelementptr inbounds float, float* %0, i64 %121
%130 = bitcast float* %129 to <4 x float>*
store <4 x float> %125, <4 x float>* %130
%131 = getelementptr inbounds float, float* %129, i64 4
%132 = bitcast float* %131 to <4 x float>*
store <4 x float> %128, <4 x float>* %132
%133 = add nuw i64 %121, 8
%134 = add i64 %122, 1
%135 = icmp eq i64 %134, %64
br i1 %135, label %136, label %120
136: ; preds = %120, %117
%137 = icmp eq i64 %60, %51
br i1 %137, label %175, label %138
138: ; preds = %53, %50, %136
%139 = phi i64 [ 0, %53 ], [ 0, %50 ], [ %60, %136 ]
%140 = xor i64 %139, -1
%141 = add nsw i64 %140, %51
%142 = and i64 %51, 3
%143 = icmp eq i64 %142, 0
br i1 %143, label %153, label %144
144: ; preds = %138, %144
%145 = phi i64 [ %150, %144 ], [ %139, %138 ]
%146 = phi i64 [ %151, %144 ], [ 0, %138 ]
%147 = getelementptr inbounds float, float* %19, i64 %145
%148 = load float, float* %147
%149 = getelementptr inbounds float, float* %0, i64 %145
store float %148, float* %149
%150 = add nuw nsw i64 %145, 1
%151 = add i64 %146, 1
%152 = icmp eq i64 %151, %142
br i1 %152, label %153, label %144
153: ; preds = %144, %138
%154 = phi i64 [ %139, %138 ], [ %150, %144 ]
%155 = icmp ult i64 %141, 3
br i1 %155, label %175, label %156
156: ; preds = %153, %156
%157 = phi i64 [ %173, %156 ], [ %154, %153 ]
%158 = getelementptr inbounds float, float* %19, i64 %157
%159 = load float, float* %158
%160 = getelementptr inbounds float, float* %0, i64 %157
store float %159, float* %160
%161 = add nuw nsw i64 %157, 1
%162 = getelementptr inbounds float, float* %19, i64 %161
%163 = load float, float* %162
%164 = getelementptr inbounds float, float* %0, i64 %161
store float %163, float* %164
%165 = add nuw nsw i64 %157, 2
%166 = getelementptr inbounds float, float* %19, i64 %165
%167 = load float, float* %166
%168 = getelementptr inbounds float, float* %0, i64 %165
store float %167, float* %168
%169 = add nuw nsw i64 %157, 3
%170 = getelementptr inbounds float, float* %19, i64 %169
%171 = load float, float* %170
%172 = getelementptr inbounds float, float* %0, i64 %169
store float %171, float* %172
%173 = add nuw nsw i64 %157, 4
%174 = icmp eq i64 %173, %51
br i1 %174, label %175, label %156
175: ; preds = %153, %156, %136, %43
%176 = icmp ne float* %1, null
%177 = select i1 %176, i1 %48, i1 false
br i1 %177, label %178, label %303
178: ; preds = %175
%179 = zext i32 %17 to i64
%180 = icmp ult i32 %17, 8
br i1 %180, label %266, label %181
181: ; preds = %178
%182 = getelementptr float, float* %1, i64 %179
%183 = getelementptr float, float* %20, i64 %179
%184 = icmp ugt float* %183, %1
%185 = icmp ult float* %20, %182
%186 = and i1 %184, %185
br i1 %186, label %266, label %187
187: ; preds = %181
%188 = and i64 %179, 4294967288
%189 = add nsw i64 %188, -8
%190 = lshr exact i64 %189, 3
%191 = add nuw nsw i64 %190, 1
%192 = and i64 %191, 3
%193 = icmp ult i64 %189, 24
br i1 %193, label %245, label %194
194: ; preds = %187
%195 = and i64 %191, 4611686018427387900
br label %196
196: ; preds = %196, %194
%197 = phi i64 [ 0, %194 ], [ %242, %196 ]
%198 = phi i64 [ 0, %194 ], [ %243, %196 ]
%199 = getelementptr inbounds float, float* %20, i64 %197
%200 = bitcast float* %199 to <4 x float>*
%201 = load <4 x float>, <4 x float>* %200
%202 = getelementptr inbounds float, float* %199, i64 4
%203 = bitcast float* %202 to <4 x float>*
%204 = load <4 x float>, <4 x float>* %203
%205 = getelementptr inbounds float, float* %1, i64 %197
%206 = bitcast float* %205 to <4 x float>*
store <4 x float> %201, <4 x float>* %206
%207 = getelementptr inbounds float, float* %205, i64 4
%208 = bitcast float* %207 to <4 x float>*
store <4 x float> %204, <4 x float>* %208
%209 = or i64 %197, 8
%210 = getelementptr inbounds float, float* %20, i64 %209
%211 = bitcast float* %210 to <4 x float>*
%212 = load <4 x float>, <4 x float>* %211
%213 = getelementptr inbounds float, float* %210, i64 4
%214 = bitcast float* %213 to <4 x float>*
%215 = load <4 x float>, <4 x float>* %214
%216 = getelementptr inbounds float, float* %1, i64 %209
%217 = bitcast float* %216 to <4 x float>*
store <4 x float> %212, <4 x float>* %217
%218 = getelementptr inbounds float, float* %216, i64 4
%219 = bitcast float* %218 to <4 x float>*
store <4 x float> %215, <4 x float>* %219
%220 = or i64 %197, 16
%221 = getelementptr inbounds float, float* %20, i64 %220
%222 = bitcast float* %221 to <4 x float>*
%223 = load <4 x float>, <4 x float>* %222
%224 = getelementptr inbounds float, float* %221, i64 4
%225 = bitcast float* %224 to <4 x float>*
%226 = load <4 x float>, <4 x float>* %225
%227 = getelementptr inbounds float, float* %1, i64 %220
%228 = bitcast float* %227 to <4 x float>*
store <4 x float> %223, <4 x float>* %228
%229 = getelementptr inbounds float, float* %227, i64 4
%230 = bitcast float* %229 to <4 x float>*
store <4 x float> %226, <4 x float>* %230
%231 = or i64 %197, 24
%232 = getelementptr inbounds float, float* %20, i64 %231
%233 = bitcast float* %232 to <4 x float>*
%234 = load <4 x float>, <4 x float>* %233
%235 = getelementptr inbounds float, float* %232, i64 4
%236 = bitcast float* %235 to <4 x float>*
%237 = load <4 x float>, <4 x float>* %236
%238 = getelementptr inbounds float, float* %1, i64 %231
%239 = bitcast float* %238 to <4 x float>*
store <4 x float> %234, <4 x float>* %239
%240 = getelementptr inbounds float, float* %238, i64 4
%241 = bitcast float* %240 to <4 x float>*
store <4 x float> %237, <4 x float>* %241
%242 = add nuw i64 %197, 32
%243 = add i64 %198, 4
%244 = icmp eq i64 %243, %195
br i1 %244, label %245, label %196
245: ; preds = %196, %187
%246 = phi i64 [ 0, %187 ], [ %242, %196 ]
%247 = icmp eq i64 %192, 0
br i1 %247, label %264, label %248
248: ; preds = %245, %248
%249 = phi i64 [ %261, %248 ], [ %246, %245 ]
%250 = phi i64 [ %262, %248 ], [ 0, %245 ]
%251 = getelementptr inbounds float, float* %20, i64 %249
%252 = bitcast float* %251 to <4 x float>*
%253 = load <4 x float>, <4 x float>* %252
%254 = getelementptr inbounds float, float* %251, i64 4
%255 = bitcast float* %254 to <4 x float>*
%256 = load <4 x float>, <4 x float>* %255
%257 = getelementptr inbounds float, float* %1, i64 %249
%258 = bitcast float* %257 to <4 x float>*
store <4 x float> %253, <4 x float>* %258
%259 = getelementptr inbounds float, float* %257, i64 4
%260 = bitcast float* %259 to <4 x float>*
store <4 x float> %256, <4 x float>* %260
%261 = add nuw i64 %249, 8
%262 = add i64 %250, 1
%263 = icmp eq i64 %262, %192
br i1 %263, label %264, label %248
264: ; preds = %248, %245
%265 = icmp eq i64 %188, %179
br i1 %265, label %303, label %266
266: ; preds = %181, %178, %264
%267 = phi i64 [ 0, %181 ], [ 0, %178 ], [ %188, %264 ]
%268 = xor i64 %267, -1
%269 = add nsw i64 %268, %179
%270 = and i64 %179, 3
%271 = icmp eq i64 %270, 0
br i1 %271, label %281, label %272
272: ; preds = %266, %272
%273 = phi i64 [ %278, %272 ], [ %267, %266 ]
%274 = phi i64 [ %279, %272 ], [ 0, %266 ]
%275 = getelementptr inbounds float, float* %20, i64 %273
%276 = load float, float* %275
%277 = getelementptr inbounds float, float* %1, i64 %273
store float %276, float* %277
%278 = add nuw nsw i64 %273, 1
%279 = add i64 %274, 1
%280 = icmp eq i64 %279, %270
br i1 %280, label %281, label %272
281: ; preds = %272, %266
%282 = phi i64 [ %267, %266 ], [ %278, %272 ]
%283 = icmp ult i64 %269, 3
br i1 %283, label %303, label %284
284: ; preds = %281, %284
%285 = phi i64 [ %301, %284 ], [ %282, %281 ]
%286 = getelementptr inbounds float, float* %20, i64 %285
%287 = load float, float* %286
%288 = getelementptr inbounds float, float* %1, i64 %285
store float %287, float* %288
%289 = add nuw nsw i64 %285, 1
%290 = getelementptr inbounds float, float* %20, i64 %289
%291 = load float, float* %290
%292 = getelementptr inbounds float, float* %1, i64 %289
store float %291, float* %292
%293 = add nuw nsw i64 %285, 2
%294 = getelementptr inbounds float, float* %20, i64 %293
%295 = load float, float* %294
%296 = getelementptr inbounds float, float* %1, i64 %293
store float %295, float* %296
%297 = add nuw nsw i64 %285, 3
%298 = getelementptr inbounds float, float* %20, i64 %297
%299 = load float, float* %298
%300 = getelementptr inbounds float, float* %1, i64 %297
store float %299, float* %300
%301 = add nuw nsw i64 %285, 4
%302 = icmp eq i64 %301, %179
br i1 %302, label %303, label %284
303: ; preds = %281, %284, %264, %175
%304 = icmp eq float* %29, null
br i1 %304, label %307, label %305
305: ; preds = %303
%306 = tail call i32 @morsi_dilation(float* %29, float* %19, i32 %13, i32 %14, i32* %15)
br label %307
307: ; preds = %305, %303
%308 = icmp eq float* %37, null
br i1 %308, label %311, label %309
309: ; preds = %307
%310 = tail call i32 @morsi_erosion(float* %37, float* %20, i32 %13, i32 %14, i32* %15)
br label %311
311: ; preds = %309, %307
%312 = icmp ne float* %4, null
%313 = select i1 %312, i1 %48, i1 false
br i1 %313, label %314, label %456
314: ; preds = %311
%315 = zext i32 %17 to i64
%316 = icmp ult i32 %17, 8
br i1 %316, label %404, label %317
317: ; preds = %314
%318 = getelementptr float, float* %4, i64 %315
%319 = getelementptr float, float* %20, i64 %315
%320 = getelementptr float, float* %19, i64 %315
%321 = icmp ugt float* %319, %4
%322 = icmp ult float* %20, %318
%323 = and i1 %321, %322
%324 = icmp ugt float* %320, %4
%325 = icmp ult float* %19, %318
%326 = and i1 %324, %325
%327 = or i1 %323, %326
br i1 %327, label %404, label %328
328: ; preds = %317
%329 = and i64 %315, 4294967288
%330 = add nsw i64 %329, -8
%331 = lshr exact i64 %330, 3
%332 = add nuw nsw i64 %331, 1
%333 = and i64 %332, 1
%334 = icmp eq i64 %330, 0
br i1 %334, label %380, label %335
335: ; preds = %328
%336 = and i64 %332, 4611686018427387902
br label %337
337: ; preds = %337, %335
%338 = phi i64 [ 0, %335 ], [ %377, %337 ]
%339 = phi i64 [ 0, %335 ], [ %378, %337 ]
%340 = getelementptr inbounds float, float* %20, i64 %338
%341 = bitcast float* %340 to <4 x float>*
%342 = load <4 x float>, <4 x float>* %341
%343 = getelementptr inbounds float, float* %340, i64 4
%344 = bitcast float* %343 to <4 x float>*
%345 = load <4 x float>, <4 x float>* %344
%346 = getelementptr inbounds float, float* %19, i64 %338
%347 = bitcast float* %346 to <4 x float>*
%348 = load <4 x float>, <4 x float>* %347
%349 = getelementptr inbounds float, float* %346, i64 4
%350 = bitcast float* %349 to <4 x float>*
%351 = load <4 x float>, <4 x float>* %350
%352 = fsub <4 x float> %342, %348
%353 = fsub <4 x float> %345, %351
%354 = getelementptr inbounds float, float* %4, i64 %338
%355 = bitcast float* %354 to <4 x float>*
store <4 x float> %352, <4 x float>* %355
%356 = getelementptr inbounds float, float* %354, i64 4
%357 = bitcast float* %356 to <4 x float>*
store <4 x float> %353, <4 x float>* %357
%358 = or i64 %338, 8
%359 = getelementptr inbounds float, float* %20, i64 %358
%360 = bitcast float* %359 to <4 x float>*
%361 = load <4 x float>, <4 x float>* %360
%362 = getelementptr inbounds float, float* %359, i64 4
%363 = bitcast float* %362 to <4 x float>*
%364 = load <4 x float>, <4 x float>* %363
%365 = getelementptr inbounds float, float* %19, i64 %358
%366 = bitcast float* %365 to <4 x float>*
%367 = load <4 x float>, <4 x float>* %366
%368 = getelementptr inbounds float, float* %365, i64 4
%369 = bitcast float* %368 to <4 x float>*
%370 = load <4 x float>, <4 x float>* %369
%371 = fsub <4 x float> %361, %367
%372 = fsub <4 x float> %364, %370
%373 = getelementptr inbounds float, float* %4, i64 %358
%374 = bitcast float* %373 to <4 x float>*
store <4 x float> %371, <4 x float>* %374
%375 = getelementptr inbounds float, float* %373, i64 4
%376 = bitcast float* %375 to <4 x float>*
store <4 x float> %372, <4 x float>* %376
%377 = add nuw i64 %338, 16
%378 = add i64 %339, 2
%379 = icmp eq i64 %378, %336
br i1 %379, label %380, label %337
380: ; preds = %337, %328
%381 = phi i64 [ 0, %328 ], [ %377, %337 ]
%382 = icmp eq i64 %333, 0
br i1 %382, label %402, label %383
383: ; preds = %380
%384 = getelementptr inbounds float, float* %20, i64 %381
%385 = bitcast float* %384 to <4 x float>*
%386 = load <4 x float>, <4 x float>* %385
%387 = getelementptr inbounds float, float* %384, i64 4
%388 = bitcast float* %387 to <4 x float>*
%389 = load <4 x float>, <4 x float>* %388
%390 = getelementptr inbounds float, float* %19, i64 %381
%391 = bitcast float* %390 to <4 x float>*
%392 = load <4 x float>, <4 x float>* %391
%393 = getelementptr inbounds float, float* %390, i64 4
%394 = bitcast float* %393 to <4 x float>*
%395 = load <4 x float>, <4 x float>* %394
%396 = fsub <4 x float> %386, %392
%397 = fsub <4 x float> %389, %395
%398 = getelementptr inbounds float, float* %4, i64 %381
%399 = bitcast float* %398 to <4 x float>*
store <4 x float> %396, <4 x float>* %399
%400 = getelementptr inbounds float, float* %398, i64 4
%401 = bitcast float* %400 to <4 x float>*
store <4 x float> %397, <4 x float>* %401
br label %402
402: ; preds = %380, %383
%403 = icmp eq i64 %329, %315
br i1 %403, label %456, label %404
404: ; preds = %317, %314, %402
%405 = phi i64 [ 0, %317 ], [ 0, %314 ], [ %329, %402 ]
%406 = xor i64 %405, -1
%407 = add nsw i64 %406, %315
%408 = and i64 %315, 3
%409 = icmp eq i64 %408, 0
br i1 %409, label %422, label %410
410: ; preds = %404, %410
%411 = phi i64 [ %419, %410 ], [ %405, %404 ]
%412 = phi i64 [ %420, %410 ], [ 0, %404 ]
%413 = getelementptr inbounds float, float* %20, i64 %411
%414 = load float, float* %413
%415 = getelementptr inbounds float, float* %19, i64 %411
%416 = load float, float* %415
%417 = fsub float %414, %416
%418 = getelementptr inbounds float, float* %4, i64 %411
store float %417, float* %418
%419 = add nuw nsw i64 %411, 1
%420 = add i64 %412, 1
%421 = icmp eq i64 %420, %408
br i1 %421, label %422, label %410
422: ; preds = %410, %404
%423 = phi i64 [ %405, %404 ], [ %419, %410 ]
%424 = icmp ult i64 %407, 3
br i1 %424, label %456, label %425
425: ; preds = %422, %425
%426 = phi i64 [ %454, %425 ], [ %423, %422 ]
%427 = getelementptr inbounds float, float* %20, i64 %426
%428 = load float, float* %427
%429 = getelementptr inbounds float, float* %19, i64 %426
%430 = load float, float* %429
%431 = fsub float %428, %430
%432 = getelementptr inbounds float, float* %4, i64 %426
store float %431, float* %432
%433 = add nuw nsw i64 %426, 1
%434 = getelementptr inbounds float, float* %20, i64 %433
%435 = load float, float* %434
%436 = getelementptr inbounds float, float* %19, i64 %433
%437 = load float, float* %436
%438 = fsub float %435, %437
%439 = getelementptr inbounds float, float* %4, i64 %433
store float %438, float* %439
%440 = add nuw nsw i64 %426, 2
%441 = getelementptr inbounds float, float* %20, i64 %440
%442 = load float, float* %441
%443 = getelementptr inbounds float, float* %19, i64 %440
%444 = load float, float* %443
%445 = fsub float %442, %444
%446 = getelementptr inbounds float, float* %4, i64 %440
store float %445, float* %446
%447 = add nuw nsw i64 %426, 3
%448 = getelementptr inbounds float, float* %20, i64 %447
%449 = load float, float* %448
%450 = getelementptr inbounds float, float* %19, i64 %447
%451 = load float, float* %450
%452 = fsub float %449, %451
%453 = getelementptr inbounds float, float* %4, i64 %447
store float %452, float* %453
%454 = add nuw nsw i64 %426, 4
%455 = icmp eq i64 %454, %315
br i1 %455, label %456, label %425
456: ; preds = %422, %425, %402, %311
%457 = icmp ne float* %5, null
%458 = select i1 %457, i1 %48, i1 false
br i1 %458, label %459, label %601
459: ; preds = %456
%460 = zext i32 %17 to i64
%461 = icmp ult i32 %17, 8
br i1 %461, label %549, label %462
462: ; preds = %459
%463 = getelementptr float, float* %5, i64 %460
%464 = getelementptr float, float* %12, i64 %460
%465 = getelementptr float, float* %19, i64 %460
%466 = icmp ugt float* %464, %5
%467 = icmp ugt float* %463, %12
%468 = and i1 %466, %467
%469 = icmp ugt float* %465, %5
%470 = icmp ult float* %19, %463
%471 = and i1 %469, %470
%472 = or i1 %468, %471
br i1 %472, label %549, label %473
473: ; preds = %462
%474 = and i64 %460, 4294967288
%475 = add nsw i64 %474, -8
%476 = lshr exact i64 %475, 3
%477 = add nuw nsw i64 %476, 1
%478 = and i64 %477, 1
%479 = icmp eq i64 %475, 0
br i1 %479, label %525, label %480
480: ; preds = %473
%481 = and i64 %477, 4611686018427387902
br label %482
482: ; preds = %482, %480
%483 = phi i64 [ 0, %480 ], [ %522, %482 ]
%484 = phi i64 [ 0, %480 ], [ %523, %482 ]
%485 = getelementptr inbounds float, float* %12, i64 %483
%486 = bitcast float* %485 to <4 x float>*
%487 = load <4 x float>, <4 x float>* %486
%488 = getelementptr inbounds float, float* %485, i64 4
%489 = bitcast float* %488 to <4 x float>*
%490 = load <4 x float>, <4 x float>* %489
%491 = getelementptr inbounds float, float* %19, i64 %483
%492 = bitcast float* %491 to <4 x float>*
%493 = load <4 x float>, <4 x float>* %492
%494 = getelementptr inbounds float, float* %491, i64 4
%495 = bitcast float* %494 to <4 x float>*
%496 = load <4 x float>, <4 x float>* %495
%497 = fsub <4 x float> %487, %493
%498 = fsub <4 x float> %490, %496
%499 = getelementptr inbounds float, float* %5, i64 %483
%500 = bitcast float* %499 to <4 x float>*
store <4 x float> %497, <4 x float>* %500
%501 = getelementptr inbounds float, float* %499, i64 4
%502 = bitcast float* %501 to <4 x float>*
store <4 x float> %498, <4 x float>* %502
%503 = or i64 %483, 8
%504 = getelementptr inbounds float, float* %12, i64 %503
%505 = bitcast float* %504 to <4 x float>*
%506 = load <4 x float>, <4 x float>* %505
%507 = getelementptr inbounds float, float* %504, i64 4
%508 = bitcast float* %507 to <4 x float>*
%509 = load <4 x float>, <4 x float>* %508
%510 = getelementptr inbounds float, float* %19, i64 %503
%511 = bitcast float* %510 to <4 x float>*
%512 = load <4 x float>, <4 x float>* %511
%513 = getelementptr inbounds float, float* %510, i64 4
%514 = bitcast float* %513 to <4 x float>*
%515 = load <4 x float>, <4 x float>* %514
%516 = fsub <4 x float> %506, %512
%517 = fsub <4 x float> %509, %515
%518 = getelementptr inbounds float, float* %5, i64 %503
%519 = bitcast float* %518 to <4 x float>*
store <4 x float> %516, <4 x float>* %519
%520 = getelementptr inbounds float, float* %518, i64 4
%521 = bitcast float* %520 to <4 x float>*
store <4 x float> %517, <4 x float>* %521
%522 = add nuw i64 %483, 16
%523 = add i64 %484, 2
%524 = icmp eq i64 %523, %481
br i1 %524, label %525, label %482
525: ; preds = %482, %473
%526 = phi i64 [ 0, %473 ], [ %522, %482 ]
%527 = icmp eq i64 %478, 0
br i1 %527, label %547, label %528
528: ; preds = %525
%529 = getelementptr inbounds float, float* %12, i64 %526
%530 = bitcast float* %529 to <4 x float>*
%531 = load <4 x float>, <4 x float>* %530
%532 = getelementptr inbounds float, float* %529, i64 4
%533 = bitcast float* %532 to <4 x float>*
%534 = load <4 x float>, <4 x float>* %533
%535 = getelementptr inbounds float, float* %19, i64 %526
%536 = bitcast float* %535 to <4 x float>*
%537 = load <4 x float>, <4 x float>* %536
%538 = getelementptr inbounds float, float* %535, i64 4
%539 = bitcast float* %538 to <4 x float>*
%540 = load <4 x float>, <4 x float>* %539
%541 = fsub <4 x float> %531, %537
%542 = fsub <4 x float> %534, %540
%543 = getelementptr inbounds float, float* %5, i64 %526
%544 = bitcast float* %543 to <4 x float>*
store <4 x float> %541, <4 x float>* %544
%545 = getelementptr inbounds float, float* %543, i64 4
%546 = bitcast float* %545 to <4 x float>*
store <4 x float> %542, <4 x float>* %546
br label %547
547: ; preds = %525, %528
%548 = icmp eq i64 %474, %460
br i1 %548, label %601, label %549
549: ; preds = %462, %459, %547
%550 = phi i64 [ 0, %462 ], [ 0, %459 ], [ %474, %547 ]
%551 = xor i64 %550, -1
%552 = add nsw i64 %551, %460
%553 = and i64 %460, 3
%554 = icmp eq i64 %553, 0
br i1 %554, label %567, label %555
555: ; preds = %549, %555
%556 = phi i64 [ %564, %555 ], [ %550, %549 ]
%557 = phi i64 [ %565, %555 ], [ 0, %549 ]
%558 = getelementptr inbounds float, float* %12, i64 %556
%559 = load float, float* %558
%560 = getelementptr inbounds float, float* %19, i64 %556
%561 = load float, float* %560
%562 = fsub float %559, %561
%563 = getelementptr inbounds float, float* %5, i64 %556
store float %562, float* %563
%564 = add nuw nsw i64 %556, 1
%565 = add i64 %557, 1
%566 = icmp eq i64 %565, %553
br i1 %566, label %567, label %555
567: ; preds = %555, %549
%568 = phi i64 [ %550, %549 ], [ %564, %555 ]
%569 = icmp ult i64 %552, 3
br i1 %569, label %601, label %570
570: ; preds = %567, %570
%571 = phi i64 [ %599, %570 ], [ %568, %567 ]
%572 = getelementptr inbounds float, float* %12, i64 %571
%573 = load float, float* %572
%574 = getelementptr inbounds float, float* %19, i64 %571
%575 = load float, float* %574
%576 = fsub float %573, %575
%577 = getelementptr inbounds float, float* %5, i64 %571
store float %576, float* %577
%578 = add nuw nsw i64 %571, 1
%579 = getelementptr inbounds float, float* %12, i64 %578
%580 = load float, float* %579
%581 = getelementptr inbounds float, float* %19, i64 %578
%582 = load float, float* %581
%583 = fsub float %580, %582
%584 = getelementptr inbounds float, float* %5, i64 %578
store float %583, float* %584
%585 = add nuw nsw i64 %571, 2
%586 = getelementptr inbounds float, float* %12, i64 %585
%587 = load float, float* %586
%588 = getelementptr inbounds float, float* %19, i64 %585
%589 = load float, float* %588
%590 = fsub float %587, %589
%591 = getelementptr inbounds float, float* %5, i64 %585
store float %590, float* %591
%592 = add nuw nsw i64 %571, 3
%593 = getelementptr inbounds float, float* %12, i64 %592
%594 = load float, float* %593
%595 = getelementptr inbounds float, float* %19, i64 %592
%596 = load float, float* %595
%597 = fsub float %594, %596
%598 = getelementptr inbounds float, float* %5, i64 %592
store float %597, float* %598
%599 = add nuw nsw i64 %571, 4
%600 = icmp eq i64 %599, %460
br i1 %600, label %601, label %570
601: ; preds = %567, %570, %547, %456
%602 = icmp ne float* %6, null
%603 = select i1 %602, i1 %48, i1 false
br i1 %603, label %604, label %746
604: ; preds = %601
%605 = zext i32 %17 to i64
%606 = icmp ult i32 %17, 8
br i1 %606, label %694, label %607
607: ; preds = %604
%608 = getelementptr float, float* %6, i64 %605
%609 = getelementptr float, float* %20, i64 %605
%610 = getelementptr float, float* %12, i64 %605
%611 = icmp ugt float* %609, %6
%612 = icmp ult float* %20, %608
%613 = and i1 %611, %612
%614 = icmp ugt float* %610, %6
%615 = icmp ugt float* %608, %12
%616 = and i1 %614, %615
%617 = or i1 %613, %616
br i1 %617, label %694, label %618
618: ; preds = %607
%619 = and i64 %605, 4294967288
%620 = add nsw i64 %619, -8
%621 = lshr exact i64 %620, 3
%622 = add nuw nsw i64 %621, 1
%623 = and i64 %622, 1
%624 = icmp eq i64 %620, 0
br i1 %624, label %670, label %625
625: ; preds = %618
%626 = and i64 %622, 4611686018427387902
br label %627
627: ; preds = %627, %625
%628 = phi i64 [ 0, %625 ], [ %667, %627 ]
%629 = phi i64 [ 0, %625 ], [ %668, %627 ]
%630 = getelementptr inbounds float, float* %20, i64 %628
%631 = bitcast float* %630 to <4 x float>*
%632 = load <4 x float>, <4 x float>* %631
%633 = getelementptr inbounds float, float* %630, i64 4
%634 = bitcast float* %633 to <4 x float>*
%635 = load <4 x float>, <4 x float>* %634
%636 = getelementptr inbounds float, float* %12, i64 %628
%637 = bitcast float* %636 to <4 x float>*
%638 = load <4 x float>, <4 x float>* %637
%639 = getelementptr inbounds float, float* %636, i64 4
%640 = bitcast float* %639 to <4 x float>*
%641 = load <4 x float>, <4 x float>* %640
%642 = fsub <4 x float> %632, %638
%643 = fsub <4 x float> %635, %641
%644 = getelementptr inbounds float, float* %6, i64 %628
%645 = bitcast float* %644 to <4 x float>*
store <4 x float> %642, <4 x float>* %645
%646 = getelementptr inbounds float, float* %644, i64 4
%647 = bitcast float* %646 to <4 x float>*
store <4 x float> %643, <4 x float>* %647
%648 = or i64 %628, 8
%649 = getelementptr inbounds float, float* %20, i64 %648
%650 = bitcast float* %649 to <4 x float>*
%651 = load <4 x float>, <4 x float>* %650
%652 = getelementptr inbounds float, float* %649, i64 4
%653 = bitcast float* %652 to <4 x float>*
%654 = load <4 x float>, <4 x float>* %653
%655 = getelementptr inbounds float, float* %12, i64 %648
%656 = bitcast float* %655 to <4 x float>*
%657 = load <4 x float>, <4 x float>* %656
%658 = getelementptr inbounds float, float* %655, i64 4
%659 = bitcast float* %658 to <4 x float>*
%660 = load <4 x float>, <4 x float>* %659
%661 = fsub <4 x float> %651, %657
%662 = fsub <4 x float> %654, %660
%663 = getelementptr inbounds float, float* %6, i64 %648
%664 = bitcast float* %663 to <4 x float>*
store <4 x float> %661, <4 x float>* %664
%665 = getelementptr inbounds float, float* %663, i64 4
%666 = bitcast float* %665 to <4 x float>*
store <4 x float> %662, <4 x float>* %666
%667 = add nuw i64 %628, 16
%668 = add i64 %629, 2
%669 = icmp eq i64 %668, %626
br i1 %669, label %670, label %627
670: ; preds = %627, %618
%671 = phi i64 [ 0, %618 ], [ %667, %627 ]
%672 = icmp eq i64 %623, 0
br i1 %672, label %692, label %673
673: ; preds = %670
%674 = getelementptr inbounds float, float* %20, i64 %671
%675 = bitcast float* %674 to <4 x float>*
%676 = load <4 x float>, <4 x float>* %675
%677 = getelementptr inbounds float, float* %674, i64 4
%678 = bitcast float* %677 to <4 x float>*
%679 = load <4 x float>, <4 x float>* %678
%680 = getelementptr inbounds float, float* %12, i64 %671
%681 = bitcast float* %680 to <4 x float>*
%682 = load <4 x float>, <4 x float>* %681
%683 = getelementptr inbounds float, float* %680, i64 4
%684 = bitcast float* %683 to <4 x float>*
%685 = load <4 x float>, <4 x float>* %684
%686 = fsub <4 x float> %676, %682
%687 = fsub <4 x float> %679, %685
%688 = getelementptr inbounds float, float* %6, i64 %671
%689 = bitcast float* %688 to <4 x float>*
store <4 x float> %686, <4 x float>* %689
%690 = getelementptr inbounds float, float* %688, i64 4
%691 = bitcast float* %690 to <4 x float>*
store <4 x float> %687, <4 x float>* %691
br label %692
692: ; preds = %670, %673
%693 = icmp eq i64 %619, %605
br i1 %693, label %746, label %694
694: ; preds = %607, %604, %692
%695 = phi i64 [ 0, %607 ], [ 0, %604 ], [ %619, %692 ]
%696 = xor i64 %695, -1
%697 = add nsw i64 %696, %605
%698 = and i64 %605, 3
%699 = icmp eq i64 %698, 0
br i1 %699, label %712, label %700
700: ; preds = %694, %700
%701 = phi i64 [ %709, %700 ], [ %695, %694 ]
%702 = phi i64 [ %710, %700 ], [ 0, %694 ]
%703 = getelementptr inbounds float, float* %20, i64 %701
%704 = load float, float* %703
%705 = getelementptr inbounds float, float* %12, i64 %701
%706 = load float, float* %705
%707 = fsub float %704, %706
%708 = getelementptr inbounds float, float* %6, i64 %701
store float %707, float* %708
%709 = add nuw nsw i64 %701, 1
%710 = add i64 %702, 1
%711 = icmp eq i64 %710, %698
br i1 %711, label %712, label %700
712: ; preds = %700, %694
%713 = phi i64 [ %695, %694 ], [ %709, %700 ]
%714 = icmp ult i64 %697, 3
br i1 %714, label %746, label %715
715: ; preds = %712, %715
%716 = phi i64 [ %744, %715 ], [ %713, %712 ]
%717 = getelementptr inbounds float, float* %20, i64 %716
%718 = load float, float* %717
%719 = getelementptr inbounds float, float* %12, i64 %716
%720 = load float, float* %719
%721 = fsub float %718, %720
%722 = getelementptr inbounds float, float* %6, i64 %716
store float %721, float* %722
%723 = add nuw nsw i64 %716, 1
%724 = getelementptr inbounds float, float* %20, i64 %723
%725 = load float, float* %724
%726 = getelementptr inbounds float, float* %12, i64 %723
%727 = load float, float* %726
%728 = fsub float %725, %727
%729 = getelementptr inbounds float, float* %6, i64 %723
store float %728, float* %729
%730 = add nuw nsw i64 %716, 2
%731 = getelementptr inbounds float, float* %20, i64 %730
%732 = load float, float* %731
%733 = getelementptr inbounds float, float* %12, i64 %730
%734 = load float, float* %733
%735 = fsub float %732, %734
%736 = getelementptr inbounds float, float* %6, i64 %730
store float %735, float* %736
%737 = add nuw nsw i64 %716, 3
%738 = getelementptr inbounds float, float* %20, i64 %737
%739 = load float, float* %738
%740 = getelementptr inbounds float, float* %12, i64 %737
%741 = load float, float* %740
%742 = fsub float %739, %741
%743 = getelementptr inbounds float, float* %6, i64 %737
store float %742, float* %743
%744 = add nuw nsw i64 %716, 4
%745 = icmp eq i64 %744, %605
br i1 %745, label %746, label %715
746: ; preds = %712, %715, %692, %601
%747 = select i1 %21, i1 %48, i1 false
br i1 %747, label %748, label %890
748: ; preds = %746
%749 = zext i32 %17 to i64
%750 = icmp ult i32 %17, 8
br i1 %750, label %838, label %751
751: ; preds = %748
%752 = getelementptr float, float* %10, i64 %749
%753 = getelementptr float, float* %12, i64 %749
%754 = getelementptr float, float* %29, i64 %749
%755 = icmp ugt float* %753, %10
%756 = icmp ugt float* %752, %12
%757 = and i1 %755, %756
%758 = icmp ugt float* %754, %10
%759 = icmp ult float* %29, %752
%760 = and i1 %758, %759
%761 = or i1 %757, %760
br i1 %761, label %838, label %762
762: ; preds = %751
%763 = and i64 %749, 4294967288
%764 = add nsw i64 %763, -8
%765 = lshr exact i64 %764, 3
%766 = add nuw nsw i64 %765, 1
%767 = and i64 %766, 1
%768 = icmp eq i64 %764, 0
br i1 %768, label %814, label %769
769: ; preds = %762
%770 = and i64 %766, 4611686018427387902
br label %771
771: ; preds = %771, %769
%772 = phi i64 [ 0, %769 ], [ %811, %771 ]
%773 = phi i64 [ 0, %769 ], [ %812, %771 ]
%774 = getelementptr inbounds float, float* %12, i64 %772
%775 = bitcast float* %774 to <4 x float>*
%776 = load <4 x float>, <4 x float>* %775
%777 = getelementptr inbounds float, float* %774, i64 4
%778 = bitcast float* %777 to <4 x float>*
%779 = load <4 x float>, <4 x float>* %778
%780 = getelementptr inbounds float, float* %29, i64 %772
%781 = bitcast float* %780 to <4 x float>*
%782 = load <4 x float>, <4 x float>* %781
%783 = getelementptr inbounds float, float* %780, i64 4
%784 = bitcast float* %783 to <4 x float>*
%785 = load <4 x float>, <4 x float>* %784
%786 = fsub <4 x float> %776, %782
%787 = fsub <4 x float> %779, %785
%788 = getelementptr inbounds float, float* %10, i64 %772
%789 = bitcast float* %788 to <4 x float>*
store <4 x float> %786, <4 x float>* %789
%790 = getelementptr inbounds float, float* %788, i64 4
%791 = bitcast float* %790 to <4 x float>*
store <4 x float> %787, <4 x float>* %791
%792 = or i64 %772, 8
%793 = getelementptr inbounds float, float* %12, i64 %792
%794 = bitcast float* %793 to <4 x float>*
%795 = load <4 x float>, <4 x float>* %794
%796 = getelementptr inbounds float, float* %793, i64 4
%797 = bitcast float* %796 to <4 x float>*
%798 = load <4 x float>, <4 x float>* %797
%799 = getelementptr inbounds float, float* %29, i64 %792
%800 = bitcast float* %799 to <4 x float>*
%801 = load <4 x float>, <4 x float>* %800
%802 = getelementptr inbounds float, float* %799, i64 4
%803 = bitcast float* %802 to <4 x float>*
%804 = load <4 x float>, <4 x float>* %803
%805 = fsub <4 x float> %795, %801
%806 = fsub <4 x float> %798, %804
%807 = getelementptr inbounds float, float* %10, i64 %792
%808 = bitcast float* %807 to <4 x float>*
store <4 x float> %805, <4 x float>* %808
%809 = getelementptr inbounds float, float* %807, i64 4
%810 = bitcast float* %809 to <4 x float>*
store <4 x float> %806, <4 x float>* %810
%811 = add nuw i64 %772, 16
%812 = add i64 %773, 2
%813 = icmp eq i64 %812, %770
br i1 %813, label %814, label %771
814: ; preds = %771, %762
%815 = phi i64 [ 0, %762 ], [ %811, %771 ]
%816 = icmp eq i64 %767, 0
br i1 %816, label %836, label %817
817: ; preds = %814
%818 = getelementptr inbounds float, float* %12, i64 %815
%819 = bitcast float* %818 to <4 x float>*
%820 = load <4 x float>, <4 x float>* %819
%821 = getelementptr inbounds float, float* %818, i64 4
%822 = bitcast float* %821 to <4 x float>*
%823 = load <4 x float>, <4 x float>* %822
%824 = getelementptr inbounds float, float* %29, i64 %815
%825 = bitcast float* %824 to <4 x float>*
%826 = load <4 x float>, <4 x float>* %825
%827 = getelementptr inbounds float, float* %824, i64 4
%828 = bitcast float* %827 to <4 x float>*
%829 = load <4 x float>, <4 x float>* %828
%830 = fsub <4 x float> %820, %826
%831 = fsub <4 x float> %823, %829
%832 = getelementptr inbounds float, float* %10, i64 %815
%833 = bitcast float* %832 to <4 x float>*
store <4 x float> %830, <4 x float>* %833
%834 = getelementptr inbounds float, float* %832, i64 4
%835 = bitcast float* %834 to <4 x float>*
store <4 x float> %831, <4 x float>* %835
br label %836
836: ; preds = %814, %817
%837 = icmp eq i64 %763, %749
br i1 %837, label %890, label %838
838: ; preds = %751, %748, %836
%839 = phi i64 [ 0, %751 ], [ 0, %748 ], [ %763, %836 ]
%840 = xor i64 %839, -1
%841 = add nsw i64 %840, %749
%842 = and i64 %749, 3
%843 = icmp eq i64 %842, 0
br i1 %843, label %856, label %844
844: ; preds = %838, %844
%845 = phi i64 [ %853, %844 ], [ %839, %838 ]
%846 = phi i64 [ %854, %844 ], [ 0, %838 ]
%847 = getelementptr inbounds float, float* %12, i64 %845
%848 = load float, float* %847
%849 = getelementptr inbounds float, float* %29, i64 %845
%850 = load float, float* %849
%851 = fsub float %848, %850
%852 = getelementptr inbounds float, float* %10, i64 %845
store float %851, float* %852
%853 = add nuw nsw i64 %845, 1
%854 = add i64 %846, 1
%855 = icmp eq i64 %854, %842
br i1 %855, label %856, label %844
856: ; preds = %844, %838
%857 = phi i64 [ %839, %838 ], [ %853, %844 ]
%858 = icmp ult i64 %841, 3
br i1 %858, label %890, label %859
859: ; preds = %856, %859
%860 = phi i64 [ %888, %859 ], [ %857, %856 ]
%861 = getelementptr inbounds float, float* %12, i64 %860
%862 = load float, float* %861
%863 = getelementptr inbounds float, float* %29, i64 %860
%864 = load float, float* %863
%865 = fsub float %862, %864
%866 = getelementptr inbounds float, float* %10, i64 %860
store float %865, float* %866
%867 = add nuw nsw i64 %860, 1
%868 = getelementptr inbounds float, float* %12, i64 %867
%869 = load float, float* %868
%870 = getelementptr inbounds float, float* %29, i64 %867
%871 = load float, float* %870
%872 = fsub float %869, %871
%873 = getelementptr inbounds float, float* %10, i64 %867
store float %872, float* %873
%874 = add nuw nsw i64 %860, 2
%875 = getelementptr inbounds float, float* %12, i64 %874
%876 = load float, float* %875
%877 = getelementptr inbounds float, float* %29, i64 %874
%878 = load float, float* %877
%879 = fsub float %876, %878
%880 = getelementptr inbounds float, float* %10, i64 %874
store float %879, float* %880
%881 = add nuw nsw i64 %860, 3
%882 = getelementptr inbounds float, float* %12, i64 %881
%883 = load float, float* %882
%884 = getelementptr inbounds float, float* %29, i64 %881
%885 = load float, float* %884
%886 = fsub float %883, %885
%887 = getelementptr inbounds float, float* %10, i64 %881
store float %886, float* %887
%888 = add nuw nsw i64 %860, 4
%889 = icmp eq i64 %888, %749
br i1 %889, label %890, label %859
890: ; preds = %856, %859, %836, %746
%891 = select i1 %30, i1 %48, i1 false
br i1 %891, label %892, label %1034
892: ; preds = %890
%893 = zext i32 %17 to i64
%894 = icmp ult i32 %17, 8
br i1 %894, label %982, label %895
895: ; preds = %892
%896 = getelementptr float, float* %11, i64 %893
%897 = getelementptr float, float* %37, i64 %893
%898 = getelementptr float, float* %12, i64 %893
%899 = icmp ugt float* %897, %11
%900 = icmp ult float* %37, %896
%901 = and i1 %899, %900
%902 = icmp ugt float* %898, %11
%903 = icmp ugt float* %896, %12
%904 = and i1 %902, %903
%905 = or i1 %901, %904
br i1 %905, label %982, label %906
906: ; preds = %895
%907 = and i64 %893, 4294967288
%908 = add nsw i64 %907, -8
%909 = lshr exact i64 %908, 3
%910 = add nuw nsw i64 %909, 1
%911 = and i64 %910, 1
%912 = icmp eq i64 %908, 0
br i1 %912, label %958, label %913
913: ; preds = %906
%914 = and i64 %910, 4611686018427387902
br label %915
915: ; preds = %915, %913
%916 = phi i64 [ 0, %913 ], [ %955, %915 ]
%917 = phi i64 [ 0, %913 ], [ %956, %915 ]
%918 = getelementptr inbounds float, float* %37, i64 %916
%919 = bitcast float* %918 to <4 x float>*
%920 = load <4 x float>, <4 x float>* %919
%921 = getelementptr inbounds float, float* %918, i64 4
%922 = bitcast float* %921 to <4 x float>*
%923 = load <4 x float>, <4 x float>* %922
%924 = getelementptr inbounds float, float* %12, i64 %916
%925 = bitcast float* %924 to <4 x float>*
%926 = load <4 x float>, <4 x float>* %925
%927 = getelementptr inbounds float, float* %924, i64 4
%928 = bitcast float* %927 to <4 x float>*
%929 = load <4 x float>, <4 x float>* %928
%930 = fsub <4 x float> %920, %926
%931 = fsub <4 x float> %923, %929
%932 = getelementptr inbounds float, float* %11, i64 %916
%933 = bitcast float* %932 to <4 x float>*
store <4 x float> %930, <4 x float>* %933
%934 = getelementptr inbounds float, float* %932, i64 4
%935 = bitcast float* %934 to <4 x float>*
store <4 x float> %931, <4 x float>* %935
%936 = or i64 %916, 8
%937 = getelementptr inbounds float, float* %37, i64 %936
%938 = bitcast float* %937 to <4 x float>*
%939 = load <4 x float>, <4 x float>* %938
%940 = getelementptr inbounds float, float* %937, i64 4
%941 = bitcast float* %940 to <4 x float>*
%942 = load <4 x float>, <4 x float>* %941
%943 = getelementptr inbounds float, float* %12, i64 %936
%944 = bitcast float* %943 to <4 x float>*
%945 = load <4 x float>, <4 x float>* %944
%946 = getelementptr inbounds float, float* %943, i64 4
%947 = bitcast float* %946 to <4 x float>*
%948 = load <4 x float>, <4 x float>* %947
%949 = fsub <4 x float> %939, %945
%950 = fsub <4 x float> %942, %948
%951 = getelementptr inbounds float, float* %11, i64 %936
%952 = bitcast float* %951 to <4 x float>*
store <4 x float> %949, <4 x float>* %952
%953 = getelementptr inbounds float, float* %951, i64 4
%954 = bitcast float* %953 to <4 x float>*
store <4 x float> %950, <4 x float>* %954
%955 = add nuw i64 %916, 16
%956 = add i64 %917, 2
%957 = icmp eq i64 %956, %914
br i1 %957, label %958, label %915
958: ; preds = %915, %906
%959 = phi i64 [ 0, %906 ], [ %955, %915 ]
%960 = icmp eq i64 %911, 0
br i1 %960, label %980, label %961
961: ; preds = %958
%962 = getelementptr inbounds float, float* %37, i64 %959
%963 = bitcast float* %962 to <4 x float>*
%964 = load <4 x float>, <4 x float>* %963
%965 = getelementptr inbounds float, float* %962, i64 4
%966 = bitcast float* %965 to <4 x float>*
%967 = load <4 x float>, <4 x float>* %966
%968 = getelementptr inbounds float, float* %12, i64 %959
%969 = bitcast float* %968 to <4 x float>*
%970 = load <4 x float>, <4 x float>* %969
%971 = getelementptr inbounds float, float* %968, i64 4
%972 = bitcast float* %971 to <4 x float>*
%973 = load <4 x float>, <4 x float>* %972
%974 = fsub <4 x float> %964, %970
%975 = fsub <4 x float> %967, %973
%976 = getelementptr inbounds float, float* %11, i64 %959
%977 = bitcast float* %976 to <4 x float>*
store <4 x float> %974, <4 x float>* %977
%978 = getelementptr inbounds float, float* %976, i64 4
%979 = bitcast float* %978 to <4 x float>*
store <4 x float> %975, <4 x float>* %979
br label %980
980: ; preds = %958, %961
%981 = icmp eq i64 %907, %893
br i1 %981, label %1034, label %982
982: ; preds = %895, %892, %980
%983 = phi i64 [ 0, %895 ], [ 0, %892 ], [ %907, %980 ]
%984 = xor i64 %983, -1
%985 = add nsw i64 %984, %893
%986 = and i64 %893, 3
%987 = icmp eq i64 %986, 0
br i1 %987, label %1000, label %988
988: ; preds = %982, %988
%989 = phi i64 [ %997, %988 ], [ %983, %982 ]
%990 = phi i64 [ %998, %988 ], [ 0, %982 ]
%991 = getelementptr inbounds float, float* %37, i64 %989
%992 = load float, float* %991
%993 = getelementptr inbounds float, float* %12, i64 %989
%994 = load float, float* %993
%995 = fsub float %992, %994
%996 = getelementptr inbounds float, float* %11, i64 %989
store float %995, float* %996
%997 = add nuw nsw i64 %989, 1
%998 = add i64 %990, 1
%999 = icmp eq i64 %998, %986
br i1 %999, label %1000, label %988
1000: ; preds = %988, %982
%1001 = phi i64 [ %983, %982 ], [ %997, %988 ]
%1002 = icmp ult i64 %985, 3
br i1 %1002, label %1034, label %1003
1003: ; preds = %1000, %1003
%1004 = phi i64 [ %1032, %1003 ], [ %1001, %1000 ]
%1005 = getelementptr inbounds float, float* %37, i64 %1004
%1006 = load float, float* %1005
%1007 = getelementptr inbounds float, float* %12, i64 %1004
%1008 = load float, float* %1007
%1009 = fsub float %1006, %1008
%1010 = getelementptr inbounds float, float* %11, i64 %1004
store float %1009, float* %1010
%1011 = add nuw nsw i64 %1004, 1
%1012 = getelementptr inbounds float, float* %37, i64 %1011
%1013 = load float, float* %1012
%1014 = getelementptr inbounds float, float* %12, i64 %1011
%1015 = load float, float* %1014
%1016 = fsub float %1013, %1015
%1017 = getelementptr inbounds float, float* %11, i64 %1011
store float %1016, float* %1017
%1018 = add nuw nsw i64 %1004, 2
%1019 = getelementptr inbounds float, float* %37, i64 %1018
%1020 = load float, float* %1019
%1021 = getelementptr inbounds float, float* %12, i64 %1018
%1022 = load float, float* %1021
%1023 = fsub float %1020, %1022
%1024 = getelementptr inbounds float, float* %11, i64 %1018
store float %1023, float* %1024
%1025 = add nuw nsw i64 %1004, 3
%1026 = getelementptr inbounds float, float* %37, i64 %1025
%1027 = load float, float* %1026
%1028 = getelementptr inbounds float, float* %12, i64 %1025
%1029 = load float, float* %1028
%1030 = fsub float %1027, %1029
%1031 = getelementptr inbounds float, float* %11, i64 %1025
store float %1030, float* %1031
%1032 = add nuw nsw i64 %1004, 4
%1033 = icmp eq i64 %1032, %893
br i1 %1033, label %1034, label %1003
1034: ; preds = %1000, %1003, %980, %890
%1035 = select i1 %22, i1 %48, i1 false
br i1 %1035, label %1036, label %1178
1036: ; preds = %1034
%1037 = zext i32 %17 to i64
%1038 = icmp ult i32 %17, 8
br i1 %1038, label %1126, label %1039
1039: ; preds = %1036
%1040 = getelementptr float, float* %9, i64 %1037
%1041 = getelementptr float, float* %37, i64 %1037
%1042 = getelementptr float, float* %29, i64 %1037
%1043 = icmp ugt float* %1041, %9
%1044 = icmp ult float* %37, %1040
%1045 = and i1 %1043, %1044
%1046 = icmp ugt float* %1042, %9
%1047 = icmp ult float* %29, %1040
%1048 = and i1 %1046, %1047
%1049 = or i1 %1045, %1048
br i1 %1049, label %1126, label %1050
1050: ; preds = %1039
%1051 = and i64 %1037, 4294967288
%1052 = add nsw i64 %1051, -8
%1053 = lshr exact i64 %1052, 3
%1054 = add nuw nsw i64 %1053, 1
%1055 = and i64 %1054, 1
%1056 = icmp eq i64 %1052, 0
br i1 %1056, label %1102, label %1057
1057: ; preds = %1050
%1058 = and i64 %1054, 4611686018427387902
br label %1059
1059: ; preds = %1059, %1057
%1060 = phi i64 [ 0, %1057 ], [ %1099, %1059 ]
%1061 = phi i64 [ 0, %1057 ], [ %1100, %1059 ]
%1062 = getelementptr inbounds float, float* %37, i64 %1060
%1063 = bitcast float* %1062 to <4 x float>*
%1064 = load <4 x float>, <4 x float>* %1063
%1065 = getelementptr inbounds float, float* %1062, i64 4
%1066 = bitcast float* %1065 to <4 x float>*
%1067 = load <4 x float>, <4 x float>* %1066
%1068 = getelementptr inbounds float, float* %29, i64 %1060
%1069 = bitcast float* %1068 to <4 x float>*
%1070 = load <4 x float>, <4 x float>* %1069
%1071 = getelementptr inbounds float, float* %1068, i64 4
%1072 = bitcast float* %1071 to <4 x float>*
%1073 = load <4 x float>, <4 x float>* %1072
%1074 = fsub <4 x float> %1064, %1070
%1075 = fsub <4 x float> %1067, %1073
%1076 = getelementptr inbounds float, float* %9, i64 %1060
%1077 = bitcast float* %1076 to <4 x float>*
store <4 x float> %1074, <4 x float>* %1077
%1078 = getelementptr inbounds float, float* %1076, i64 4
%1079 = bitcast float* %1078 to <4 x float>*
store <4 x float> %1075, <4 x float>* %1079
%1080 = or i64 %1060, 8
%1081 = getelementptr inbounds float, float* %37, i64 %1080
%1082 = bitcast float* %1081 to <4 x float>*
%1083 = load <4 x float>, <4 x float>* %1082
%1084 = getelementptr inbounds float, float* %1081, i64 4
%1085 = bitcast float* %1084 to <4 x float>*
%1086 = load <4 x float>, <4 x float>* %1085
%1087 = getelementptr inbounds float, float* %29, i64 %1080
%1088 = bitcast float* %1087 to <4 x float>*
%1089 = load <4 x float>, <4 x float>* %1088
%1090 = getelementptr inbounds float, float* %1087, i64 4
%1091 = bitcast float* %1090 to <4 x float>*
%1092 = load <4 x float>, <4 x float>* %1091
%1093 = fsub <4 x float> %1083, %1089
%1094 = fsub <4 x float> %1086, %1092
%1095 = getelementptr inbounds float, float* %9, i64 %1080
%1096 = bitcast float* %1095 to <4 x float>*
store <4 x float> %1093, <4 x float>* %1096
%1097 = getelementptr inbounds float, float* %1095, i64 4
%1098 = bitcast float* %1097 to <4 x float>*
store <4 x float> %1094, <4 x float>* %1098
%1099 = add nuw i64 %1060, 16
%1100 = add i64 %1061, 2
%1101 = icmp eq i64 %1100, %1058
br i1 %1101, label %1102, label %1059
1102: ; preds = %1059, %1050
%1103 = phi i64 [ 0, %1050 ], [ %1099, %1059 ]
%1104 = icmp eq i64 %1055, 0
br i1 %1104, label %1124, label %1105
1105: ; preds = %1102
%1106 = getelementptr inbounds float, float* %37, i64 %1103
%1107 = bitcast float* %1106 to <4 x float>*
%1108 = load <4 x float>, <4 x float>* %1107
%1109 = getelementptr inbounds float, float* %1106, i64 4
%1110 = bitcast float* %1109 to <4 x float>*
%1111 = load <4 x float>, <4 x float>* %1110
%1112 = getelementptr inbounds float, float* %29, i64 %1103
%1113 = bitcast float* %1112 to <4 x float>*
%1114 = load <4 x float>, <4 x float>* %1113
%1115 = getelementptr inbounds float, float* %1112, i64 4
%1116 = bitcast float* %1115 to <4 x float>*
%1117 = load <4 x float>, <4 x float>* %1116
%1118 = fsub <4 x float> %1108, %1114
%1119 = fsub <4 x float> %1111, %1117
%1120 = getelementptr inbounds float, float* %9, i64 %1103
%1121 = bitcast float* %1120 to <4 x float>*
store <4 x float> %1118, <4 x float>* %1121
%1122 = getelementptr inbounds float, float* %1120, i64 4
%1123 = bitcast float* %1122 to <4 x float>*
store <4 x float> %1119, <4 x float>* %1123
br label %1124
1124: ; preds = %1102, %1105
%1125 = icmp eq i64 %1051, %1037
br i1 %1125, label %1178, label %1126
1126: ; preds = %1039, %1036, %1124
%1127 = phi i64 [ 0, %1039 ], [ 0, %1036 ], [ %1051, %1124 ]
%1128 = xor i64 %1127, -1
%1129 = add nsw i64 %1128, %1037
%1130 = and i64 %1037, 3
%1131 = icmp eq i64 %1130, 0
br i1 %1131, label %1144, label %1132
1132: ; preds = %1126, %1132
%1133 = phi i64 [ %1141, %1132 ], [ %1127, %1126 ]
%1134 = phi i64 [ %1142, %1132 ], [ 0, %1126 ]
%1135 = getelementptr inbounds float, float* %37, i64 %1133
%1136 = load float, float* %1135
%1137 = getelementptr inbounds float, float* %29, i64 %1133
%1138 = load float, float* %1137
%1139 = fsub float %1136, %1138
%1140 = getelementptr inbounds float, float* %9, i64 %1133
store float %1139, float* %1140
%1141 = add nuw nsw i64 %1133, 1
%1142 = add i64 %1134, 1
%1143 = icmp eq i64 %1142, %1130
br i1 %1143, label %1144, label %1132
1144: ; preds = %1132, %1126
%1145 = phi i64 [ %1127, %1126 ], [ %1141, %1132 ]
%1146 = icmp ult i64 %1129, 3
br i1 %1146, label %1178, label %1147
1147: ; preds = %1144, %1147
%1148 = phi i64 [ %1176, %1147 ], [ %1145, %1144 ]
%1149 = getelementptr inbounds float, float* %37, i64 %1148
%1150 = load float, float* %1149
%1151 = getelementptr inbounds float, float* %29, i64 %1148
%1152 = load float, float* %1151
%1153 = fsub float %1150, %1152
%1154 = getelementptr inbounds float, float* %9, i64 %1148
store float %1153, float* %1154
%1155 = add nuw nsw i64 %1148, 1
%1156 = getelementptr inbounds float, float* %37, i64 %1155
%1157 = load float, float* %1156
%1158 = getelementptr inbounds float, float* %29, i64 %1155
%1159 = load float, float* %1158
%1160 = fsub float %1157, %1159
%1161 = getelementptr inbounds float, float* %9, i64 %1155
store float %1160, float* %1161
%1162 = add nuw nsw i64 %1148, 2
%1163 = getelementptr inbounds float, float* %37, i64 %1162
%1164 = load float, float* %1163
%1165 = getelementptr inbounds float, float* %29, i64 %1162
%1166 = load float, float* %1165
%1167 = fsub float %1164, %1166
%1168 = getelementptr inbounds float, float* %9, i64 %1162
store float %1167, float* %1168
%1169 = add nuw nsw i64 %1148, 3
%1170 = getelementptr inbounds float, float* %37, i64 %1169
%1171 = load float, float* %1170
%1172 = getelementptr inbounds float, float* %29, i64 %1169
%1173 = load float, float* %1172
%1174 = fsub float %1171, %1173
%1175 = getelementptr inbounds float, float* %9, i64 %1169
store float %1174, float* %1175
%1176 = add nuw nsw i64 %1148, 4
%1177 = icmp eq i64 %1176, %1037
br i1 %1177, label %1178, label %1147
1178: ; preds = %1144, %1147, %1124, %1034
%1179 = icmp ne float* %44, null
%1180 = select i1 %1179, i1 %48, i1 false
br i1 %1180, label %1181, label %1282
1181: ; preds = %1178
%1182 = zext i32 %17 to i64
%1183 = icmp ult i32 %17, 8
br i1 %1183, label %1236, label %1184
1184: ; preds = %1181
%1185 = getelementptr float, float* %44, i64 %1182
%1186 = getelementptr float, float* %20, i64 %1182
%1187 = getelementptr float, float* %19, i64 %1182
%1188 = getelementptr float, float* %12, i64 %1182
%1189 = icmp ult float* %44, %1186
%1190 = icmp ult float* %20, %1185
%1191 = and i1 %1189, %1190
%1192 = icmp ult float* %44, %1187
%1193 = icmp ult float* %19, %1185
%1194 = and i1 %1192, %1193
%1195 = or i1 %1191, %1194
%1196 = icmp ult float* %44, %1188
%1197 = icmp ugt float* %1185, %12
%1198 = and i1 %1196, %1197
%1199 = or i1 %1195, %1198
br i1 %1199, label %1236, label %1200
1200: ; preds = %1184
%1201 = and i64 %1182, 4294967288
br label %1202
1202: ; preds = %1202, %1200
%1203 = phi i64 [ 0, %1200 ], [ %1232, %1202 ]
%1204 = getelementptr inbounds float, float* %20, i64 %1203
%1205 = bitcast float* %1204 to <4 x float>*
%1206 = load <4 x float>, <4 x float>* %1205
%1207 = getelementptr inbounds float, float* %1204, i64 4
%1208 = bitcast float* %1207 to <4 x float>*
%1209 = load <4 x float>, <4 x float>* %1208
%1210 = getelementptr inbounds float, float* %19, i64 %1203
%1211 = bitcast float* %1210 to <4 x float>*
%1212 = load <4 x float>, <4 x float>* %1211
%1213 = getelementptr inbounds float, float* %1210, i64 4
%1214 = bitcast float* %1213 to <4 x float>*
%1215 = load <4 x float>, <4 x float>* %1214
%1216 = fadd <4 x float> %1206, %1212
%1217 = fadd <4 x float> %1209, %1215
%1218 = getelementptr inbounds float, float* %12, i64 %1203
%1219 = bitcast float* %1218 to <4 x float>*
%1220 = load <4 x float>, <4 x float>* %1219
%1221 = getelementptr inbounds float, float* %1218, i64 4
%1222 = bitcast float* %1221 to <4 x float>*
%1223 = load <4 x float>, <4 x float>* %1222
%1224 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1220, <4 x float> <float -2.000000e+00, float -2.000000e+00, float -2.000000e+00, float -2.000000e+00>, <4 x float> %1216)
%1225 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1223, <4 x float> <float -2.000000e+00, float -2.000000e+00, float -2.000000e+00, float -2.000000e+00>, <4 x float> %1217)
%1226 = fmul <4 x float> %1224, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%1227 = fmul <4 x float> %1225, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%1228 = getelementptr inbounds float, float* %44, i64 %1203
%1229 = bitcast float* %1228 to <4 x float>*
store <4 x float> %1226, <4 x float>* %1229
%1230 = getelementptr inbounds float, float* %1228, i64 4
%1231 = bitcast float* %1230 to <4 x float>*
store <4 x float> %1227, <4 x float>* %1231
%1232 = add nuw i64 %1203, 8
%1233 = icmp eq i64 %1232, %1201
br i1 %1233, label %1234, label %1202
1234: ; preds = %1202
%1235 = icmp eq i64 %1201, %1182
br i1 %1235, label %1282, label %1236
1236: ; preds = %1184, %1181, %1234
%1237 = phi i64 [ 0, %1184 ], [ 0, %1181 ], [ %1201, %1234 ]
%1238 = xor i64 %1237, -1
%1239 = and i64 %1182, 1
%1240 = icmp eq i64 %1239, 0
br i1 %1240, label %1253, label %1241
1241: ; preds = %1236
%1242 = getelementptr inbounds float, float* %20, i64 %1237
%1243 = load float, float* %1242
%1244 = getelementptr inbounds float, float* %19, i64 %1237
%1245 = load float, float* %1244
%1246 = fadd float %1243, %1245
%1247 = getelementptr inbounds float, float* %12, i64 %1237
%1248 = load float, float* %1247
%1249 = tail call float @llvm.fmuladd.f32(float %1248, float -2.000000e+00, float %1246)
%1250 = fmul float %1249, 5.000000e-01
%1251 = getelementptr inbounds float, float* %44, i64 %1237
store float %1250, float* %1251
%1252 = or i64 %1237, 1
br label %1253
1253: ; preds = %1241, %1236
%1254 = phi i64 [ %1237, %1236 ], [ %1252, %1241 ]
%1255 = sub nsw i64 0, %1182
%1256 = icmp eq i64 %1238, %1255
br i1 %1256, label %1282, label %1257
1257: ; preds = %1253, %1257
%1258 = phi i64 [ %1280, %1257 ], [ %1254, %1253 ]
%1259 = getelementptr inbounds float, float* %20, i64 %1258
%1260 = load float, float* %1259
%1261 = getelementptr inbounds float, float* %19, i64 %1258
%1262 = load float, float* %1261
%1263 = fadd float %1260, %1262
%1264 = getelementptr inbounds float, float* %12, i64 %1258
%1265 = load float, float* %1264
%1266 = tail call float @llvm.fmuladd.f32(float %1265, float -2.000000e+00, float %1263)
%1267 = fmul float %1266, 5.000000e-01
%1268 = getelementptr inbounds float, float* %44, i64 %1258
store float %1267, float* %1268
%1269 = add nuw nsw i64 %1258, 1
%1270 = getelementptr inbounds float, float* %20, i64 %1269
%1271 = load float, float* %1270
%1272 = getelementptr inbounds float, float* %19, i64 %1269
%1273 = load float, float* %1272
%1274 = fadd float %1271, %1273
%1275 = getelementptr inbounds float, float* %12, i64 %1269
%1276 = load float, float* %1275
%1277 = tail call float @llvm.fmuladd.f32(float %1276, float -2.000000e+00, float %1274)
%1278 = fmul float %1277, 5.000000e-01
%1279 = getelementptr inbounds float, float* %44, i64 %1269
store float %1278, float* %1279
%1280 = add nuw nsw i64 %1258, 2
%1281 = icmp eq i64 %1280, %1182
br i1 %1281, label %1282, label %1257
1282: ; preds = %1253, %1257, %1234, %1178
%1283 = xor i1 %38, true
%1284 = select i1 %1283, i1 %48, i1 false
br i1 %1284, label %1285, label %1427
1285: ; preds = %1282
%1286 = zext i32 %17 to i64
%1287 = icmp ult i32 %17, 8
br i1 %1287, label %1375, label %1288
1288: ; preds = %1285
%1289 = getelementptr float, float* %8, i64 %1286
%1290 = getelementptr float, float* %12, i64 %1286
%1291 = getelementptr float, float* %44, i64 %1286
%1292 = icmp ugt float* %1290, %8
%1293 = icmp ugt float* %1289, %12
%1294 = and i1 %1292, %1293
%1295 = icmp ugt float* %1291, %8
%1296 = icmp ult float* %44, %1289
%1297 = and i1 %1295, %1296
%1298 = or i1 %1294, %1297
br i1 %1298, label %1375, label %1299
1299: ; preds = %1288
%1300 = and i64 %1286, 4294967288
%1301 = add nsw i64 %1300, -8
%1302 = lshr exact i64 %1301, 3
%1303 = add nuw nsw i64 %1302, 1
%1304 = and i64 %1303, 1
%1305 = icmp eq i64 %1301, 0
br i1 %1305, label %1351, label %1306
1306: ; preds = %1299
%1307 = and i64 %1303, 4611686018427387902
br label %1308
1308: ; preds = %1308, %1306
%1309 = phi i64 [ 0, %1306 ], [ %1348, %1308 ]
%1310 = phi i64 [ 0, %1306 ], [ %1349, %1308 ]
%1311 = getelementptr inbounds float, float* %12, i64 %1309
%1312 = bitcast float* %1311 to <4 x float>*
%1313 = load <4 x float>, <4 x float>* %1312
%1314 = getelementptr inbounds float, float* %1311, i64 4
%1315 = bitcast float* %1314 to <4 x float>*
%1316 = load <4 x float>, <4 x float>* %1315
%1317 = getelementptr inbounds float, float* %44, i64 %1309
%1318 = bitcast float* %1317 to <4 x float>*
%1319 = load <4 x float>, <4 x float>* %1318
%1320 = getelementptr inbounds float, float* %1317, i64 4
%1321 = bitcast float* %1320 to <4 x float>*
%1322 = load <4 x float>, <4 x float>* %1321
%1323 = fsub <4 x float> %1313, %1319
%1324 = fsub <4 x float> %1316, %1322
%1325 = getelementptr inbounds float, float* %8, i64 %1309
%1326 = bitcast float* %1325 to <4 x float>*
store <4 x float> %1323, <4 x float>* %1326
%1327 = getelementptr inbounds float, float* %1325, i64 4
%1328 = bitcast float* %1327 to <4 x float>*
store <4 x float> %1324, <4 x float>* %1328
%1329 = or i64 %1309, 8
%1330 = getelementptr inbounds float, float* %12, i64 %1329
%1331 = bitcast float* %1330 to <4 x float>*
%1332 = load <4 x float>, <4 x float>* %1331
%1333 = getelementptr inbounds float, float* %1330, i64 4
%1334 = bitcast float* %1333 to <4 x float>*
%1335 = load <4 x float>, <4 x float>* %1334
%1336 = getelementptr inbounds float, float* %44, i64 %1329
%1337 = bitcast float* %1336 to <4 x float>*
%1338 = load <4 x float>, <4 x float>* %1337
%1339 = getelementptr inbounds float, float* %1336, i64 4
%1340 = bitcast float* %1339 to <4 x float>*
%1341 = load <4 x float>, <4 x float>* %1340
%1342 = fsub <4 x float> %1332, %1338
%1343 = fsub <4 x float> %1335, %1341
%1344 = getelementptr inbounds float, float* %8, i64 %1329
%1345 = bitcast float* %1344 to <4 x float>*
store <4 x float> %1342, <4 x float>* %1345
%1346 = getelementptr inbounds float, float* %1344, i64 4
%1347 = bitcast float* %1346 to <4 x float>*
store <4 x float> %1343, <4 x float>* %1347
%1348 = add nuw i64 %1309, 16
%1349 = add i64 %1310, 2
%1350 = icmp eq i64 %1349, %1307
br i1 %1350, label %1351, label %1308
1351: ; preds = %1308, %1299
%1352 = phi i64 [ 0, %1299 ], [ %1348, %1308 ]
%1353 = icmp eq i64 %1304, 0
br i1 %1353, label %1373, label %1354
1354: ; preds = %1351
%1355 = getelementptr inbounds float, float* %12, i64 %1352
%1356 = bitcast float* %1355 to <4 x float>*
%1357 = load <4 x float>, <4 x float>* %1356
%1358 = getelementptr inbounds float, float* %1355, i64 4
%1359 = bitcast float* %1358 to <4 x float>*
%1360 = load <4 x float>, <4 x float>* %1359
%1361 = getelementptr inbounds float, float* %44, i64 %1352
%1362 = bitcast float* %1361 to <4 x float>*
%1363 = load <4 x float>, <4 x float>* %1362
%1364 = getelementptr inbounds float, float* %1361, i64 4
%1365 = bitcast float* %1364 to <4 x float>*
%1366 = load <4 x float>, <4 x float>* %1365
%1367 = fsub <4 x float> %1357, %1363
%1368 = fsub <4 x float> %1360, %1366
%1369 = getelementptr inbounds float, float* %8, i64 %1352
%1370 = bitcast float* %1369 to <4 x float>*
store <4 x float> %1367, <4 x float>* %1370
%1371 = getelementptr inbounds float, float* %1369, i64 4
%1372 = bitcast float* %1371 to <4 x float>*
store <4 x float> %1368, <4 x float>* %1372
br label %1373
1373: ; preds = %1351, %1354
%1374 = icmp eq i64 %1300, %1286
br i1 %1374, label %1427, label %1375
1375: ; preds = %1288, %1285, %1373
%1376 = phi i64 [ 0, %1288 ], [ 0, %1285 ], [ %1300, %1373 ]
%1377 = xor i64 %1376, -1
%1378 = add nsw i64 %1377, %1286
%1379 = and i64 %1286, 3
%1380 = icmp eq i64 %1379, 0
br i1 %1380, label %1393, label %1381
1381: ; preds = %1375, %1381
%1382 = phi i64 [ %1390, %1381 ], [ %1376, %1375 ]
%1383 = phi i64 [ %1391, %1381 ], [ 0, %1375 ]
%1384 = getelementptr inbounds float, float* %12, i64 %1382
%1385 = load float, float* %1384
%1386 = getelementptr inbounds float, float* %44, i64 %1382
%1387 = load float, float* %1386
%1388 = fsub float %1385, %1387
%1389 = getelementptr inbounds float, float* %8, i64 %1382
store float %1388, float* %1389
%1390 = add nuw nsw i64 %1382, 1
%1391 = add i64 %1383, 1
%1392 = icmp eq i64 %1391, %1379
br i1 %1392, label %1393, label %1381
1393: ; preds = %1381, %1375
%1394 = phi i64 [ %1376, %1375 ], [ %1390, %1381 ]
%1395 = icmp ult i64 %1378, 3
br i1 %1395, label %1427, label %1396
1396: ; preds = %1393, %1396
%1397 = phi i64 [ %1425, %1396 ], [ %1394, %1393 ]
%1398 = getelementptr inbounds float, float* %12, i64 %1397
%1399 = load float, float* %1398
%1400 = getelementptr inbounds float, float* %44, i64 %1397
%1401 = load float, float* %1400
%1402 = fsub float %1399, %1401
%1403 = getelementptr inbounds float, float* %8, i64 %1397
store float %1402, float* %1403
%1404 = add nuw nsw i64 %1397, 1
%1405 = getelementptr inbounds float, float* %12, i64 %1404
%1406 = load float, float* %1405
%1407 = getelementptr inbounds float, float* %44, i64 %1404
%1408 = load float, float* %1407
%1409 = fsub float %1406, %1408
%1410 = getelementptr inbounds float, float* %8, i64 %1404
store float %1409, float* %1410
%1411 = add nuw nsw i64 %1397, 2
%1412 = getelementptr inbounds float, float* %12, i64 %1411
%1413 = load float, float* %1412
%1414 = getelementptr inbounds float, float* %44, i64 %1411
%1415 = load float, float* %1414
%1416 = fsub float %1413, %1415
%1417 = getelementptr inbounds float, float* %8, i64 %1411
store float %1416, float* %1417
%1418 = add nuw nsw i64 %1397, 3
%1419 = getelementptr inbounds float, float* %12, i64 %1418
%1420 = load float, float* %1419
%1421 = getelementptr inbounds float, float* %44, i64 %1418
%1422 = load float, float* %1421
%1423 = fsub float %1420, %1422
%1424 = getelementptr inbounds float, float* %8, i64 %1418
store float %1423, float* %1424
%1425 = add nuw nsw i64 %1397, 4
%1426 = icmp eq i64 %1425, %1286
br i1 %1426, label %1427, label %1396
1427: ; preds = %1393, %1396, %1373, %1282
%1428 = tail call i32 @free(float* %19)
%1429 = tail call i32 @free(float* %20)
br i1 %25, label %1430, label %1432
1430: ; preds = %1427
%1431 = tail call i32 @free(float* %29)
br label %1432
1432: ; preds = %1430, %1427
br i1 %33, label %1433, label %1435
1433: ; preds = %1432
%1434 = tail call i32 @free(float* %37)
br label %1435
1435: ; preds = %1433, %1432
br i1 %40, label %1438, label %1436
1436: ; preds = %1435
%1437 = tail call i32 @free(float* %44)
br label %1438
1438: ; preds = %1436, %1435
ret void
}