int dist1(blk1, blk2, lx, hx, hy, h, distlim)
unsigned char *blk1, *blk2;
int lx, hx, hy, h;
int distlim;
{
  unsigned char *p1, *p1a, *p2;
  int i, j;
  int s, v;
  s = 0;
  p1 = blk1;
  p2 = blk2;
  if (!hx && !hy)
    for (j = 0; j < h; j++) {
      if ((v = p1[0] - p2[0]) < 0)
        v = -v;
      s += v;
      if ((v = p1[1] - p2[1]) < 0)
        v = -v;
      s += v;
      if ((v = p1[2] - p2[2]) < 0)
        v = -v;
      s += v;
      if ((v = p1[3] - p2[3]) < 0)
        v = -v;
      s += v;
      if ((v = p1[4] - p2[4]) < 0)
        v = -v;
      s += v;
      if ((v = p1[5] - p2[5]) < 0)
        v = -v;
      s += v;
      if ((v = p1[6] - p2[6]) < 0)
        v = -v;
      s += v;
      if ((v = p1[7] - p2[7]) < 0)
        v = -v;
      s += v;
      if ((v = p1[8] - p2[8]) < 0)
        v = -v;
      s += v;
      if ((v = p1[9] - p2[9]) < 0)
        v = -v;
      s += v;
      if ((v = p1[10] - p2[10]) < 0)
        v = -v;
      s += v;
      if ((v = p1[11] - p2[11]) < 0)
        v = -v;
      s += v;
      if ((v = p1[12] - p2[12]) < 0)
        v = -v;
      s += v;
      if ((v = p1[13] - p2[13]) < 0)
        v = -v;
      s += v;
      if ((v = p1[14] - p2[14]) < 0)
        v = -v;
      s += v;
      if ((v = p1[15] - p2[15]) < 0)
        v = -v;
      s += v;
      if (s >= distlim)
        break;
      p1 += lx;
      p2 += lx;
    }
  else if (hx && !hy)
    for (j = 0; j < h; j++) {
      for (i = 0; i < 16; i++) {
        v = ((unsigned int)(p1[i] + p1[i + 1] + 1) >> 1) - p2[i];
        if (v >= 0)
          s += v;
        else
          s -= v;
      }
      p1 += lx;
      p2 += lx;
    }
  else if (!hx && hy) {
    p1a = p1 + lx;
    for (j = 0; j < h; j++) {
      for (i = 0; i < 16; i++) {
        v = ((unsigned int)(p1[i] + p1a[i] + 1) >> 1) - p2[i];
        if (v >= 0)
          s += v;
        else
          s -= v;
      }
      p1 = p1a;
      p1a += lx;
      p2 += lx;
    }
  } else {
    p1a = p1 + lx;
    for (j = 0; j < h; j++) {
      for (i = 0; i < 16; i++) {
        v = ((unsigned int)(p1[i] + p1[i + 1] + p1a[i] + p1a[i + 1] + 2) >> 2) -
            p2[i];
        if (v >= 0)
          s += v;
        else
          s -= v;
      }
      p1 = p1a;
      p1a += lx;
      p2 += lx;
    }
  }
  return s;
}


x86 assembly (clang, -O0):
<dist1>:
push   %rbp
mov    %rsp,%rbp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
cmpl   $0x0,-0x18(%rbp)
jne    148f <dist1+0x38f>
cmpl   $0x0,-0x1c(%rbp)
jne    148f <dist1+0x38f>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    148a <dist1+0x38a>
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
mov    -0x38(%rbp),%rcx
movzbl (%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
cmp    $0x0,%eax
jge    117f <dist1+0x7f>
xor    %eax,%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    -0x38(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
cmp    $0x0,%eax
jge    11ae <dist1+0xae>
xor    %eax,%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
movzbl 0x2(%rax),%eax
mov    -0x38(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
cmp    $0x0,%eax
jge    11dd <dist1+0xdd>
xor    %eax,%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
movzbl 0x3(%rax),%eax
mov    -0x38(%rbp),%rcx
movzbl 0x3(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
cmp    $0x0,%eax
jge    120c <dist1+0x10c>
xor    %eax,%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
movzbl 0x4(%rax),%eax
mov    -0x38(%rbp),%rcx
movzbl 0x4(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
cmp    $0x0,%eax
jge    123b <dist1+0x13b>
xor    %eax,%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
movzbl 0x5(%rax),%eax
mov    -0x38(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
cmp    $0x0,%eax
jge    126a <dist1+0x16a>
xor    %eax,%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
movzbl 0x6(%rax),%eax
mov    -0x38(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
cmp    $0x0,%eax
jge    1299 <dist1+0x199>
xor    %eax,%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
movzbl 0x7(%rax),%eax
mov    -0x38(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
cmp    $0x0,%eax
jge    12c8 <dist1+0x1c8>
xor    %eax,%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
movzbl 0x8(%rax),%eax
mov    -0x38(%rbp),%rcx
movzbl 0x8(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
cmp    $0x0,%eax
jge    12f7 <dist1+0x1f7>
xor    %eax,%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
movzbl 0x9(%rax),%eax
mov    -0x38(%rbp),%rcx
movzbl 0x9(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
cmp    $0x0,%eax
jge    1326 <dist1+0x226>
xor    %eax,%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
movzbl 0xa(%rax),%eax
mov    -0x38(%rbp),%rcx
movzbl 0xa(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
cmp    $0x0,%eax
jge    1355 <dist1+0x255>
xor    %eax,%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
movzbl 0xb(%rax),%eax
mov    -0x38(%rbp),%rcx
movzbl 0xb(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
cmp    $0x0,%eax
jge    1384 <dist1+0x284>
xor    %eax,%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
movzbl 0xc(%rax),%eax
mov    -0x38(%rbp),%rcx
movzbl 0xc(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
cmp    $0x0,%eax
jge    13b3 <dist1+0x2b3>
xor    %eax,%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
movzbl 0xd(%rax),%eax
mov    -0x38(%rbp),%rcx
movzbl 0xd(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
cmp    $0x0,%eax
jge    13e2 <dist1+0x2e2>
xor    %eax,%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
movzbl 0xe(%rax),%eax
mov    -0x38(%rbp),%rcx
movzbl 0xe(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
cmp    $0x0,%eax
jge    1411 <dist1+0x311>
xor    %eax,%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
movzbl 0xf(%rax),%eax
mov    -0x38(%rbp),%rcx
movzbl 0xf(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
cmp    $0x0,%eax
jge    1440 <dist1+0x340>
xor    %eax,%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x10(%rbp),%eax
jl     145a <dist1+0x35a>
jmp    148a <dist1+0x38a>
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    114f <dist1+0x4f>
jmp    175a <dist1+0x65a>
cmpl   $0x0,-0x18(%rbp)
je     1568 <dist1+0x468>
cmpl   $0x0,-0x1c(%rbp)
jne    1568 <dist1+0x468>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1563 <dist1+0x463>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x10,-0x3c(%rbp)
jge    1533 <dist1+0x433>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x28(%rbp),%rcx
mov    -0x3c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%eax
shr    $0x1,%eax
mov    -0x38(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x48(%rbp)
jl     1515 <dist1+0x415>
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    1520 <dist1+0x420>
mov    -0x48(%rbp),%ecx
mov    -0x44(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x44(%rbp)
jmp    1525 <dist1+0x425>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14bd <dist1+0x3bd>
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    14aa <dist1+0x3aa>
jmp    1755 <dist1+0x655>
cmpl   $0x0,-0x18(%rbp)
jne    1653 <dist1+0x553>
cmpl   $0x0,-0x1c(%rbp)
je     1653 <dist1+0x553>
mov    -0x28(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    164e <dist1+0x54e>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x10,-0x3c(%rbp)
jge    1616 <dist1+0x516>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x30(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%eax
shr    $0x1,%eax
mov    -0x38(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x48(%rbp)
jl     15f8 <dist1+0x4f8>
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    1603 <dist1+0x503>
mov    -0x48(%rbp),%ecx
mov    -0x44(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x44(%rbp)
jmp    1608 <dist1+0x508>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    15a5 <dist1+0x4a5>
mov    -0x30(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1592 <dist1+0x492>
jmp    1750 <dist1+0x650>
mov    -0x28(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    174b <dist1+0x64b>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x10,-0x3c(%rbp)
jge    1713 <dist1+0x613>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x28(%rbp),%rcx
mov    -0x3c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x30(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    -0x3c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x2,%eax
shr    $0x2,%eax
mov    -0x38(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x48(%rbp)
jl     16f5 <dist1+0x5f5>
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    1700 <dist1+0x600>
mov    -0x48(%rbp),%ecx
mov    -0x44(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x44(%rbp)
jmp    1705 <dist1+0x605>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    167c <dist1+0x57c>
mov    -0x30(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1669 <dist1+0x569>
jmp    1750 <dist1+0x650>
jmp    1755 <dist1+0x655>
jmp    175a <dist1+0x65a>
mov    -0x44(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<dist1>:
mov    %r8d,%eax
or     %ecx,%eax
je     1342 <dist1+0x242>
test   %ecx,%ecx
je     139e <dist1+0x29e>
test   %r8d,%r8d
jne    139e <dist1+0x29e>
test   %r9d,%r9d
jle    188f <dist1+0x78f>
movslq %edx,%r8
xor    %edx,%edx
movaps 0xece(%rip),%xmm8
pxor   %xmm13,%xmm13
pcmpeqd %xmm9,%xmm9
xor    %eax,%eax
xchg   %ax,%ax
movzbl (%rdi,%rdx,1),%ecx
movd   %ecx,%xmm0
pslld  $0x18,%xmm0
movss  0x1(%rdi,%rdx,1),%xmm10
xorps  %xmm12,%xmm12
movss  %xmm0,%xmm12
movaps %xmm10,%xmm14
movaps %xmm10,%xmm3
movss  0x5(%rdi,%rdx,1),%xmm11
movaps %xmm11,%xmm15
movaps %xmm11,%xmm7
movss  0x9(%rdi,%rdx,1),%xmm1
movaps %xmm1,%xmm2
movaps %xmm1,%xmm4
movss  0xd(%rdi,%rdx,1),%xmm5
movaps %xmm5,%xmm6
andps  %xmm8,%xmm6
orps   %xmm1,%xmm6
andps  %xmm8,%xmm1
orps   %xmm11,%xmm1
andps  %xmm8,%xmm11
orps   %xmm10,%xmm11
andps  %xmm8,%xmm10
orps   %xmm10,%xmm12
psrld  $0x18,%xmm12
pslld  $0x8,%xmm14
por    %xmm12,%xmm14
punpcklbw %xmm13,%xmm14
punpcklwd %xmm13,%xmm14
punpcklbw %xmm13,%xmm3
punpcklwd %xmm13,%xmm3
paddd  %xmm14,%xmm3
psubd  %xmm9,%xmm3
psrld  $0x1,%xmm3
movd   (%rsi,%rdx,1),%xmm0
punpcklbw %xmm13,%xmm0
punpcklwd %xmm13,%xmm0
psubd  %xmm0,%xmm3
movdqa %xmm3,%xmm0
psrad  $0x1f,%xmm0
paddd  %xmm0,%xmm3
pxor   %xmm0,%xmm3
psrld  $0x18,%xmm11
pslld  $0x8,%xmm15
por    %xmm11,%xmm15
punpcklbw %xmm13,%xmm15
punpcklwd %xmm13,%xmm15
punpcklbw %xmm13,%xmm7
punpcklwd %xmm13,%xmm7
paddd  %xmm15,%xmm7
psubd  %xmm9,%xmm7
psrld  $0x1,%xmm7
movd   0x4(%rsi,%rdx,1),%xmm0
punpcklbw %xmm13,%xmm0
punpcklwd %xmm13,%xmm0
psubd  %xmm0,%xmm7
movdqa %xmm7,%xmm0
psrad  $0x1f,%xmm0
paddd  %xmm0,%xmm7
pxor   %xmm0,%xmm7
movd   %eax,%xmm0
paddd  %xmm0,%xmm7
paddd  %xmm3,%xmm7
psrld  $0x18,%xmm1
pslld  $0x8,%xmm2
por    %xmm1,%xmm2
punpcklbw %xmm13,%xmm2
punpcklwd %xmm13,%xmm2
punpcklbw %xmm13,%xmm4
punpcklwd %xmm13,%xmm4
paddd  %xmm2,%xmm4
psubd  %xmm9,%xmm4
psrld  $0x1,%xmm4
movd   0x8(%rsi,%rdx,1),%xmm0
punpcklbw %xmm13,%xmm0
punpcklwd %xmm13,%xmm0
psubd  %xmm0,%xmm4
movdqa %xmm4,%xmm0
psrad  $0x1f,%xmm0
paddd  %xmm0,%xmm4
pxor   %xmm0,%xmm4
psrld  $0x18,%xmm6
movaps %xmm5,%xmm0
pslld  $0x8,%xmm0
por    %xmm6,%xmm0
punpcklbw %xmm13,%xmm0
punpcklwd %xmm13,%xmm0
punpcklbw %xmm13,%xmm5
punpcklwd %xmm13,%xmm5
paddd  %xmm0,%xmm5
psubd  %xmm9,%xmm5
psrld  $0x1,%xmm5
movd   0xc(%rsi,%rdx,1),%xmm0
punpcklbw %xmm13,%xmm0
punpcklwd %xmm13,%xmm0
psubd  %xmm0,%xmm5
movdqa %xmm5,%xmm0
psrad  $0x1f,%xmm0
paddd  %xmm0,%xmm5
pxor   %xmm0,%xmm5
paddd  %xmm4,%xmm5
paddd  %xmm7,%xmm5
pshufd $0xee,%xmm5,%xmm0
paddd  %xmm5,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
add    %r8,%rdx
add    $0xffffffff,%r9d
jne    1140 <dist1+0x40>
jmp    188e <dist1+0x78e>
test   %r9d,%r9d
jle    188f <dist1+0x78f>
mov    0x8(%rsp),%r8d
movslq %edx,%r10
xor    %ecx,%ecx
mov    $0x1,%edx
xor    %eax,%eax
nopl   0x0(%rax)
mov    %eax,%r11d
movdqu (%rdi,%rcx,1),%xmm0
movdqu (%rsi,%rcx,1),%xmm1
psadbw %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddq  %xmm1,%xmm0
movd   %xmm0,%eax
add    %r11d,%eax
cmp    %r8d,%eax
jge    188e <dist1+0x78e>
lea    0x1(%rdx),%r11d
add    %r10,%rcx
cmp    %r9d,%edx
mov    %r11d,%edx
jl     1360 <dist1+0x260>
jmp    188e <dist1+0x78e>
movslq %edx,%r10
test   %ecx,%ecx
jne    1539 <dist1+0x439>
test   %r8d,%r8d
je     1539 <dist1+0x439>
test   %r9d,%r9d
jle    188f <dist1+0x78f>
lea    (%rdi,%r10,1),%rcx
xor    %eax,%eax
mov    $0xc,%edx
pxor   %xmm0,%xmm0
pcmpeqd %xmm1,%xmm1
xchg   %ax,%ax
movd   %eax,%xmm3
movd   -0xc(%rdi,%rdx,1),%xmm4
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
movd   -0xc(%rcx,%rdx,1),%xmm2
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
paddd  %xmm4,%xmm2
psubd  %xmm1,%xmm2
psrld  $0x1,%xmm2
movd   -0xc(%rsi,%rdx,1),%xmm4
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
psubd  %xmm4,%xmm2
movdqa %xmm2,%xmm4
psrad  $0x1f,%xmm4
paddd  %xmm4,%xmm2
pxor   %xmm4,%xmm2
paddd  %xmm3,%xmm2
movd   -0x8(%rdi,%rdx,1),%xmm3
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
movd   -0x8(%rcx,%rdx,1),%xmm4
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
paddd  %xmm3,%xmm4
psubd  %xmm1,%xmm4
psrld  $0x1,%xmm4
movd   -0x8(%rsi,%rdx,1),%xmm3
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
psubd  %xmm3,%xmm4
movdqa %xmm4,%xmm3
psrad  $0x1f,%xmm3
paddd  %xmm3,%xmm4
pxor   %xmm3,%xmm4
movd   -0x4(%rdi,%rdx,1),%xmm5
punpcklbw %xmm0,%xmm5
punpcklwd %xmm0,%xmm5
movd   -0x4(%rcx,%rdx,1),%xmm3
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
paddd  %xmm5,%xmm3
psubd  %xmm1,%xmm3
psrld  $0x1,%xmm3
movd   -0x4(%rsi,%rdx,1),%xmm5
punpcklbw %xmm0,%xmm5
punpcklwd %xmm0,%xmm5
psubd  %xmm5,%xmm3
movdqa %xmm3,%xmm5
psrad  $0x1f,%xmm5
paddd  %xmm5,%xmm3
pxor   %xmm5,%xmm3
paddd  %xmm4,%xmm3
paddd  %xmm2,%xmm3
movd   (%rdi,%rdx,1),%xmm2
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
movd   (%rcx,%rdx,1),%xmm4
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
paddd  %xmm2,%xmm4
psubd  %xmm1,%xmm4
psrld  $0x1,%xmm4
movd   (%rsi,%rdx,1),%xmm2
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
psubd  %xmm2,%xmm4
movdqa %xmm4,%xmm2
psrad  $0x1f,%xmm2
paddd  %xmm2,%xmm4
pxor   %xmm2,%xmm4
paddd  %xmm3,%xmm4
pshufd $0xee,%xmm4,%xmm2
paddd  %xmm4,%xmm2
pshufd $0x55,%xmm2,%xmm3
paddd  %xmm2,%xmm3
movd   %xmm3,%eax
add    %r10,%rdx
add    $0xffffffff,%r9d
jne    13d0 <dist1+0x2d0>
jmp    188e <dist1+0x78e>
test   %r9d,%r9d
jle    188f <dist1+0x78f>
mov    (%rdi),%cl
lea    (%rdi,%r10,1),%r11
xor    %edx,%edx
xor    %eax,%eax
nopl   0x0(%rax)
movzbl %cl,%ecx
movd   %ecx,%xmm11
movzbl (%r11,%rdx,1),%r8d
pslld  $0x18,%xmm11
movd   %r8d,%xmm3
pslld  $0x18,%xmm3
movss  0x1(%rdi,%rdx,1),%xmm0
movaps %xmm0,%xmm2
movaps %xmm0,%xmm6
movss  0x5(%rdi,%rdx,1),%xmm5
movaps %xmm5,-0x18(%rsp)
movaps %xmm5,-0x38(%rsp)
movss  0x9(%rdi,%rdx,1),%xmm15
movaps %xmm15,%xmm10
movaps %xmm15,%xmm4
movaps 0xa60(%rip),%xmm14
andps  %xmm14,%xmm4
orps   %xmm5,%xmm4
movaps %xmm4,-0x28(%rsp)
andps  %xmm14,%xmm5
orps   %xmm0,%xmm5
andps  %xmm14,%xmm0
xorps  %xmm1,%xmm1
movss  %xmm11,%xmm1
orps   %xmm0,%xmm1
psrld  $0x18,%xmm1
pslld  $0x8,%xmm2
por    %xmm1,%xmm2
xorps  %xmm4,%xmm4
punpcklbw %xmm4,%xmm2
punpcklwd %xmm4,%xmm2
punpcklbw %xmm4,%xmm6
punpcklwd %xmm4,%xmm6
paddd  %xmm2,%xmm6
movss  0x1(%r11,%rdx,1),%xmm8
pxor   %xmm1,%xmm1
movss  %xmm3,%xmm1
movaps %xmm8,%xmm9
movaps %xmm8,%xmm0
movss  0x5(%r11,%rdx,1),%xmm3
movaps %xmm3,%xmm7
movaps %xmm3,%xmm2
movss  0x9(%r11,%rdx,1),%xmm11
movaps %xmm11,%xmm13
andps  %xmm14,%xmm13
orps   %xmm3,%xmm13
andps  %xmm14,%xmm3
orps   %xmm8,%xmm3
andps  %xmm14,%xmm8
orps   %xmm8,%xmm1
psrld  $0x18,%xmm1
pslld  $0x8,%xmm9
por    %xmm1,%xmm9
movss  0xd(%rdi,%rdx,1),%xmm1
movaps %xmm1,%xmm8
andps  %xmm14,%xmm8
orps   %xmm15,%xmm8
punpcklbw %xmm4,%xmm9
punpcklwd %xmm4,%xmm9
paddd  %xmm6,%xmm9
movaps %xmm11,%xmm12
punpcklbw %xmm4,%xmm0
punpcklwd %xmm4,%xmm0
movdqa 0x99d(%rip),%xmm6
paddd  %xmm6,%xmm0
paddd  %xmm9,%xmm0
psrld  $0x2,%xmm0
movd   (%rsi,%rdx,1),%xmm6
punpcklbw %xmm4,%xmm6
punpcklwd %xmm4,%xmm6
psubd  %xmm6,%xmm0
movdqa %xmm0,%xmm6
psrad  $0x1f,%xmm6
paddd  %xmm6,%xmm0
pxor   %xmm6,%xmm0
movd   %eax,%xmm6
paddd  %xmm6,%xmm0
psrld  $0x18,%xmm5
movdqa -0x18(%rsp),%xmm6
pslld  $0x8,%xmm6
por    %xmm5,%xmm6
movss  0xd(%r11,%rdx,1),%xmm5
movaps %xmm5,%xmm9
andps  %xmm14,%xmm9
orps   %xmm11,%xmm9
punpcklbw %xmm4,%xmm6
punpcklwd %xmm4,%xmm6
movdqa -0x38(%rsp),%xmm14
punpcklbw %xmm4,%xmm14
punpcklwd %xmm4,%xmm14
paddd  %xmm6,%xmm14
psrld  $0x18,%xmm3
pslld  $0x8,%xmm7
por    %xmm3,%xmm7
punpcklbw %xmm4,%xmm7
punpcklwd %xmm4,%xmm7
punpcklbw %xmm4,%xmm2
punpcklwd %xmm4,%xmm2
paddd  %xmm7,%xmm2
paddd  %xmm14,%xmm2
movdqa 0x8f1(%rip),%xmm6
paddd  %xmm6,%xmm2
psrld  $0x2,%xmm2
movd   0x4(%rsi,%rdx,1),%xmm3
punpcklbw %xmm4,%xmm3
punpcklwd %xmm4,%xmm3
psubd  %xmm3,%xmm2
movdqa %xmm2,%xmm3
psrad  $0x1f,%xmm3
paddd  %xmm3,%xmm2
pxor   %xmm3,%xmm2
movdqa -0x28(%rsp),%xmm3
psrld  $0x18,%xmm3
pslld  $0x8,%xmm10
por    %xmm3,%xmm10
punpcklbw %xmm4,%xmm10
punpcklwd %xmm4,%xmm10
punpcklbw %xmm4,%xmm15
punpcklwd %xmm4,%xmm15
paddd  %xmm10,%xmm15
psrld  $0x18,%xmm13
pslld  $0x8,%xmm12
por    %xmm13,%xmm12
punpcklbw %xmm4,%xmm12
punpcklwd %xmm4,%xmm12
punpcklbw %xmm4,%xmm11
punpcklwd %xmm4,%xmm11
paddd  %xmm12,%xmm11
paddd  %xmm15,%xmm11
paddd  %xmm6,%xmm11
psrld  $0x2,%xmm11
movd   0x8(%rsi,%rdx,1),%xmm3
punpcklbw %xmm4,%xmm3
punpcklwd %xmm4,%xmm3
psubd  %xmm3,%xmm11
movdqa %xmm11,%xmm3
psrad  $0x1f,%xmm3
paddd  %xmm3,%xmm11
pxor   %xmm3,%xmm11
paddd  %xmm2,%xmm11
paddd  %xmm0,%xmm11
psrld  $0x18,%xmm8
movaps %xmm1,%xmm0
pslld  $0x8,%xmm0
por    %xmm8,%xmm0
punpcklbw %xmm4,%xmm0
punpcklwd %xmm4,%xmm0
punpcklbw %xmm4,%xmm1
punpcklwd %xmm4,%xmm1
paddd  %xmm0,%xmm1
psrld  $0x18,%xmm9
movaps %xmm5,%xmm0
pslld  $0x8,%xmm0
por    %xmm9,%xmm0
punpcklbw %xmm4,%xmm0
punpcklwd %xmm4,%xmm0
punpcklbw %xmm4,%xmm5
punpcklwd %xmm4,%xmm5
paddd  %xmm0,%xmm5
paddd  %xmm1,%xmm5
paddd  %xmm6,%xmm5
psrld  $0x2,%xmm5
movd   0xc(%rsi,%rdx,1),%xmm0
punpcklbw %xmm4,%xmm0
punpcklwd %xmm4,%xmm0
psubd  %xmm0,%xmm5
movdqa %xmm5,%xmm0
psrad  $0x1f,%xmm0
paddd  %xmm0,%xmm5
pxor   %xmm0,%xmm5
paddd  %xmm11,%xmm5
pshufd $0xee,%xmm5,%xmm0
paddd  %xmm5,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
add    %r10,%rdx
mov    %r8d,%ecx
add    $0xffffffff,%r9d
jne    1550 <dist1+0x450>
ret
xor    %eax,%eax
ret

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

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